---
title: "Srianta bunachar sonraí sonracha PostgreSQL"
version: 6.0
locale: ga
source: https://docs.djangoproject.com/ga/6.0/ref/contrib/postgres/constraints/
canonical: https://djangodocs.dev/ga/6.0/ref/contrib/postgres/constraints/
---
# Srianta bunachar sonraí sonracha PostgreSQL

Tacaíonn PostgreSQL le srianta breise sláine sonraí atá ar fáil ón modúl django.contrib.postgres.restricints'. \<django.db.models.Options.constraints\>Cuirtear iad leis sa rogha samhail: attr: Meta.Constraints .

## `Srianadh eisiaim`

#### `class ExclusionConstraint(* (Keyword-only parameters separator (PEP 3102)), name, expressions, index_type=None, condition=None, deferrable=None, include=None, violation_error_code=None, violation_error_message=None)`

Cruthaíonn sé srian eisiaimh sa bhunachar sonraí. Go hinmheánach, cuireann PostgreSQL srianta eisiaimh i bhfeidhm ag úsáid innéacsanna. \< <https://www.postgresql.org/docs/current/gist.html>\>Is é Gist \`\_ an cineál innéacs réamhshocraithe. \< https://www.postgresql.org/docs/current/btree-gist.html\>Chun iad a úsáid, ní mór duit an síneadh \`btree\_gist \`\_ a ghníomhachtú ar PostgreSQL. Is féidir leat é a shuiteáil ag baint úsáide as an oibríocht imirce:class: \`~django.contrib.postgres.operations.btreegistExtension.

Má dhéanann tú iarracht sraith nua a chur isteach a dhéanann coinbhleacht leis an tsraith atá ann cheana, ardaítear an:exc: ~django.db.IntegrityError. Ar an gcaoi chéanna, nuair a nuashonraítear coinbhleachtaí le sraith

\<validating-objects\>Déantar srianta eisiaimh a sheiceáil le linn an: ref: bailíochtú samhail .

### ainm \`

#### `ExclusionConstraint.name`

Féach: attr: .baseConstraint.name.

### `léiritheach`

#### `ExclusionConstraint.expressions`

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

> **Srianta ar oibreoirí.**
>
> Ní féidir ach oibreoirí comutaitheacha a úsáid i srianta eisiaimh.

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éacsa`

#### `ExclusionConstraint.index_type`

Cineál innéacs an srianta. Is iad na luachanna a nglactar leo ná `GIST` nó `SPGIST`. Tá an meaitseáil neamh-íogair. Mura gcuirtear ar fáil, is é GIST an cineál innéacs réamhshocraithe.

### `coinníoll`

#### `ExclusionConstraint.condition`

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.

### `iarchurraithe`

#### `ExclusionConstraint.deferrable`

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.

> **Warning**
>
> \< <https://www.postgresql.org/docs/current/sql-createtable.html#id-1.9.3.85.9.4>\>D'fhéadfadh “pionós feidhmíochta” \_ a bheith mar thoradh ar srianta eisiaimh iarchurtha.

### san áireamh \`\`

#### `ExclusionConstraint.include`

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

Tacaítear le `include` d'innéacsanna GiST. Tacaíonn PostgreSQL 14+ le `include` le haghaidh innéacsanna SP-Gist freisin.

### cód\_earráid\_shárú \`

#### `ExclusionConstraint.violation_error_code`

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

\<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í

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