Srianta bunachar sonraí sonracha PostgreSQLLink to this heading#

``ainm `Link to this heading#

ExclusionConstraint.nameLink to this definition#

Féach: attr: .baseConstraint.name.

léiritheachLink to this heading#

ExclusionConstraint.expressionsLink to this definition#

Athraitheach de 2-tuples. Is é an chéad eilimint ná abairt nó sreang. Is é an dara gné ná oibreoir SQL a léirítear mar shreang. Chun clóscríobh a sheachaint, is féidir leat: class: ~django.contrib.postgres.fields.rangeOperators a mhéapálann na hoibreoirí le teaghráin. Mar shampla:

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

Is féidir an abairt: class: `op <django.contrib.postgres.indexes.OpClass>Class () `a úsáid chun `aicme oibreora `_ saincheaptha a shonrú do na nathanna srianta. Mar shampla:

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

cruthaíonn srian eisiaimh ar circle ag baint úsáide as circle_ops.

cineál_innéacsaLink to this heading#

ExclusionConstraint.index_typeLink to this definition#

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.

coinníollLink to this heading#

ExclusionConstraint.conditionLink to this definition#

A: Aicme: ~Django.db.Models.q réad a shonraíonn an coinníoll chun srian a shrianadh le fo-thacar sraitheanna. Mar shampla, ``Condition=Q (cealaithe = bréagach) ``.

Tá na srianta bunachar sonraí céanna ag na coinníollacha seo las:attr: django.db.models.index.condition.

iarchurraitheLink to this heading#

ExclusionConstraint.deferrableLink to this definition#

Socraigh an paraiméadar seo chun srian eisiaimh in-iarchurtha a chruthú. Is iad na luachanna a nglactar leo ná Deferrable.Ferred nó Deferrable.Immediate. Mar shampla:

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

De réir réamhshocraithe ní chuirtear srianta ar iarchur. Ní chuirfear srian iarchurtha i bhfeidhm go dtí deireadh an idirbheart. Cuirfear srian láithreach i bhfeidhm díreach tar éis gach ordaithe.

``san áireamh ``Link to this heading#

ExclusionConstraint.includeLink to this definition#

Liosta nó tuipéar d'ainmneacha na réimsí atá le cur san áireamh sa srian eisiaimh clúdaigh mar cholúin neamh-lárnacha. Ligeann sé seo scananna innéacs amháin a úsáid le haghaidh ceisteanna nach roghnaíonn ach réimsí san áireamh (:attr: ~ExclusionConstraint.include) agus ní scagann ach amháin de réir réimsí innéacsaithe (:attr: ~ExclusionConstraint.Expressions).

include is supported for GiST and SP-GiST indexes.

``cód_earráid_shárú `Link to this heading#

ExclusionConstraint.violation_error_codeLink to this definition#

<validating-objects>An cód earráide a úsáidtear nuair a ardaítear ValidationError trí:ref: bailíochtú samhail `. Réamhshocraithe go ``None`.

``teachtaireachtaí earráid_shárúcháin ``Link to this heading#

<validating-objects>An teachtaireacht earráide a úsáidtear nuair a ardaítear ValidationError trí:ref: bailíochtú samhail `. Réamhshocraithe to:attr: `.baseConstraint.VIOLATION_ERROR_MESSAGE.

SamplaíLink to this heading#

Cuireann an sampla seo a leanas srian ar áirithintí forluí sa seomra céanna, gan áirithintí cealaithe a chur san áireamh:

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

Sa chás go sainmhíníonn do mhúnla raon ag baint úsáide as dhá réimse, in ionad na cineálacha raon dúchasacha PostgreSQL, ba cheart duit abairt a scríobh a úsáideann an fheidhm choibhéiseach (m.sh. TstzRange () `), agus na teorannaithe a úsáid don réimse. Is minic a bheidh na teorannaitheoirí ná ``'[) ', rud a chiallaíonn go bhfuil an teorainn íochtarach cuimsitheach agus go bhfuil an teorainn uachtarach eisiach. < https://www.postgresql.org/docs/ current/rangetypes.html #RANGETYPES -INCLUSIVITY>Is féidir leat an: class: ~django.contrib.postgres.fields.rangeBoundary a sholáthraíonn léarscáil abairt do na `teorainneacha raon `_ a úsáid. Mar shampla:

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