---
title: "Réimsí samhlacha sonracha PostgreSQL"
version: 6.1
locale: ga
source: https://docs.djangoproject.com/ga/6.1/ref/contrib/postgres/fields/
canonical: https://djangodocs.dev/ga/6.1/ref/contrib/postgres/fields/
---
# Réimsí samhlacha sonracha PostgreSQL

Tá na réimsí seo go léir ar fáil ón modúl `django.contrib.postgres.fields`.

## Na réimsí seo a innéacsú

[`Index`](/ga/6.1/ref/models/indexes/#django.db.models.Index) and [`Field.db_index`](/ga/6.1/ref/models/fields/#django.db.models.Field.db_index) both create a
B-tree index, which isn't particularly helpful when querying complex data
types. Indexes such as [`GinIndex`](/ga/6.1/ref/contrib/postgres/indexes/#django.contrib.postgres.indexes.GinIndex) and
[`GistIndex`](/ga/6.1/ref/contrib/postgres/indexes/#django.contrib.postgres.indexes.GistIndex) are better suited, though
the index choice is dependent on the queries that you're using. Generally, GiST
may be a good choice for the [range fields](#range-fields) and
[`HStoreField`](#django.contrib.postgres.fields.HStoreField), and GIN may be helpful for [`ArrayField`](#django.contrib.postgres.fields.ArrayField).

## `Arrayfield`

#### `class ArrayField(base_field, size=None, **options)`

Réimse chun liostaí sonraí a stóráil. \<ArrayField.base\_field\>Is féidir an chuid is mó de na cineálacha réimse a úsáid, agus téann tú sampla réimse eile mar an:attr: base\_field \`. \<ArrayField.size\>Féadfaidh tú a: attr: \`size \`a shonrú freisin. Is féidir \`\`Arrayfield\` a neadadh chun eagair ilthoiseach a stóráil.

Má thugann tú an réimse a:attr: ~django.db.models.field.default, déan cinnte go bhfuil sé inghlaonta mar liost\` (le haghaidh réamhshocraithe folamh) nó inghlaonta a thugann liosta (mar shampla feidhm). Trí úsáid mícheart ```default= [] ``cruthaíonn réamhshocrú inathraithe a roinntear idir gach cás de ``ArrayField```.

#### `base_field`

Is argóint riachtanach é seo.

Specifies the underlying data type and behavior for the array. It
should be an instance of a subclass of
[`Field`](/ga/6.1/ref/models/fields/#django.db.models.Field). For example, it could be an
[`IntegerField`](/ga/6.1/ref/models/fields/#django.db.models.IntegerField) or a
[`CharField`](/ga/6.1/ref/models/fields/#django.db.models.CharField). Most field types are permitted,
with the exception of those handling relational data
([`ForeignKey`](/ga/6.1/ref/models/fields/#django.db.models.ForeignKey),
[`OneToOneField`](/ga/6.1/ref/models/fields/#django.db.models.OneToOneField) and
[`ManyToManyField`](/ga/6.1/ref/models/fields/#django.db.models.ManyToManyField)) and file fields
([`FileField`](/ga/6.1/ref/models/fields/#django.db.models.FileField) and
[`ImageField`](/ga/6.1/ref/models/fields/#django.db.models.ImageField)).

Is féidir réimsí eagar a neadú - is féidir leat sampla de `Arrayfield` a shonrú mar an `base_field`. Mar shampla:

```
from django.contrib.postgres.fields import ArrayField
from django.db import models

class ChessBoard(models.Model):
    board = ArrayField(
        ArrayField(
            models.CharField(max_length=10, blank=True),
            size=8,
        ),
        size=8,
    )
```

Tarmligtear claochlú luachanna idir an bunachar sonraí agus an tsamhail, bailíochtú sonraí agus cumraíocht, agus sraitheadh go léir chuig an réimse bunúsach.

#### `size`

Is argóint roghnach é seo.

Má tá sé á rith, beidh uasmhéid ag an eagar mar a shonraítear. Cuirfear é seo ar aghaidh chuig an mbunachar sonraí, cé nach bhforfheidhmíonn PostgreSQL an srian faoi láthair.

> **Note**
>
> Agus tú ag neadú Arrayfield\`, cibé an úsáideann tú an paraiméadar méid nó nach bhfuil, éilíonn PostgreSQL go mbeidh na eagair dronuilleogach:
>
> ```
> from django.contrib.postgres.fields import ArrayField
> from django.db import models
>
>
> class Board(models.Model):
>     pieces = ArrayField(ArrayField(models.IntegerField()))
>
>
> # Valid
> Board(
>     pieces=[
>         [2, 3],
>         [2, 1],
>     ]
> )
>
> # Not valid
> Board(
>     pieces=[
>         [2, 3],
>         [2],
>     ]
> )
> ```
>
> Má theastaíonn cruthanna neamhrialta, ansin ba chóir an réimse bunúsach a dhéanamh neamhnaithe agus na luachanna a phástáil le `None`.

### Ag fiosrú `Arrayfield`

Tá roinnt cuardaigh agus claochruithe saincheaptha ann le haghaidh: class: ArrayField. Úsáidfimid an tsamhail sampla seo a leanas:

```
from django.contrib.postgres.fields import ArrayField
from django.db import models

class Post(models.Model):
    name = models.CharField(max_length=200)
    tags = ArrayField(models.CharField(max_length=200), blank=True)

    def __str__(self):
        return self.name
```

#### `Coimeád`

Cuirtear an cuardach: lookup: contains ar: class: ArrayField. Is iad na rudaí a chuirtear ar ais iad siúd ina bhfo-thacar de na sonraí iad na luachanna a rith. Úsáideann sé an oibreoir SQL @\> . Mar shampla:

```pycon
>>> Post.objects.create(name="First post", tags=["thoughts", "django"])
>>> Post.objects.create(name="Second post", tags=["thoughts"])
>>> Post.objects.create(name="Third post", tags=["tutorial", "django"])

>>> Post.objects.filter(tags__contains=["thoughts"])
<QuerySet [<Post: First post>, <Post: Second post>]>

>>> Post.objects.filter(tags__contains=["django"])
<QuerySet [<Post: First post>, <Post: Third post>]>

>>> Post.objects.filter(tags__contains=["django", "thoughts"])
<QuerySet [<Post: First post>]>
```

#### `coinneáilteo_ag`

Is é seo an inbhéar den chuardach: lookup: conté \<arrayfield.contains\>\- is iad na rudaí a chuirtear ar ais iad na rudaí ina bhfo-thacar de na luachanna a rith iad na sonraí. Úsáideann sé an oibreoir SQL `<@`. Mar shampla:

```pycon
>>> Post.objects.create(name="First post", tags=["thoughts", "django"])
>>> Post.objects.create(name="Second post", tags=["thoughts"])
>>> Post.objects.create(name="Third post", tags=["tutorial", "django"])

>>> Post.objects.filter(tags__contained_by=["thoughts", "django"])
<QuerySet [<Post: First post>, <Post: Second post>]>

>>> Post.objects.filter(tags__contained_by=["thoughts", "django", "tutorial"])
<QuerySet [<Post: First post>, <Post: Second post>, <Post: Third post>]>
```

#### `` `overlap ``

Tugann rudaí ar ais ina roinneann na sonraí aon torthaí leis na luachanna a rith. Úsáideann an t-oibreoir SQL `&&`. Mar shampla:

```pycon
>>> Post.objects.create(name="First post", tags=["thoughts", "django"])
>>> Post.objects.create(name="Second post", tags=["thoughts", "tutorial"])
>>> Post.objects.create(name="Third post", tags=["tutorial", "django"])

>>> Post.objects.filter(tags__overlap=["thoughts"])
<QuerySet [<Post: First post>, <Post: Second post>]>

>>> Post.objects.filter(tags__overlap=["thoughts", "tutorial"])
<QuerySet [<Post: First post>, <Post: Second post>, <Post: Third post>]>

>>> Post.objects.filter(tags__overlap=Post.objects.values_list("tags"))
<QuerySet [<Post: First post>, <Post: Second post>, <Post: Third post>]>
```

#### `` `len ``

Tugann sé ar ais fad an tsraith. Is iad na cuardaigh atá ar fáil ina dhiaidh sin iad siúd atá ar fáil dó:class: ~Django.db.Models.IntegerField. Mar shampla:

```pycon
>>> Post.objects.create(name="First post", tags=["thoughts", "django"])
>>> Post.objects.create(name="Second post", tags=["thoughts"])

>>> Post.objects.filter(tags__len=1)
<QuerySet [<Post: Second post>]>
```

#### Athraíonn innéacs

Athraíonn Innéacs innéacs isteach san eagar. Is féidir aon sláimhir neamh-dhiúltach a úsáid. Níl aon earráidí ann má sháraíonn sé an: attr: méid \<ArrayField.size\>\`den eagar. \<ArrayField.base\_field\>Is iad na cuardaigh atá ar fáil tar éis an claochlú iad siúd ó:attr: base\_field . Mar shampla:

```pycon
>>> Post.objects.create(name="First post", tags=["thoughts", "django"])
>>> Post.objects.create(name="Second post", tags=["thoughts"])

>>> Post.objects.filter(tags__0="thoughts")
<QuerySet [<Post: First post>, <Post: Second post>]>

>>> Post.objects.filter(tags__1__iexact="Django")
<QuerySet [<Post: First post>]>

>>> Post.objects.filter(tags__276="javascript")
<QuerySet []>
```

> **Note**
>
> Úsáideann PostgreSQL innéacsú 1-bhunaithe do réimsí eagar agus SQL amh á scríobh. Mar sin féin úsáideann na hinnéacsanna seo agus iad siúd a úsáidtear in:lookup: sliseanna \<arrayfield.slice\>\`innéacsú 0-bhunaithe chun a bheith comhsheasmhach le Python.

#### Athraitheann sliseanna

Tógann claochruithe slisní slisní slisní slisná den eagar. Is féidir aon dhá shláimhir neamh-dhiúltach a úsáid, scartha le béim amháin. Ní athraíonn na cuardaigh atá ar fáil tar éis an claochlú. Mar shampla:

```pycon
>>> Post.objects.create(name="First post", tags=["thoughts", "django"])
>>> Post.objects.create(name="Second post", tags=["thoughts"])
>>> Post.objects.create(name="Third post", tags=["django", "python", "thoughts"])

>>> Post.objects.filter(tags__0_1=["thoughts"])
<QuerySet [<Post: First post>, <Post: Second post>]>

>>> Post.objects.filter(tags__0_2__contains=["thoughts"])
<QuerySet [<Post: First post>, <Post: Second post>]>
```

> **Note**
>
> Úsáideann PostgreSQL innéacsú 1-bhunaithe do réimsí eagar agus SQL amh á scríobh. Mar sin féin úsáideann na slisní seo agus iad siúd a úsáidtear in:lookup: innéacsanna \<arrayfield.index\>\`innéacsú 0-bhunaithe chun a bheith comhsheasmhach le Python.

> **Eagraí ilthoiseach le hinnéacsanna agus slisní**
>
> Tá roinnt iompraíochta sách esoteric ag PostgreSQL nuair a úsáidtear innéacsanna agus slisní ar eagair ilthoiseach. Oibreoidh sé i gcónaí innéacsanna a úsáid chun na sonraí bunúsacha deiridh a bhaint amach, ach iompraíonn an chuid is mó de na slisní eile go aisteach ar leibhéal an bhunachar sonraí agus ní féidir le Django tacú leo ar bhealach loighciúil, comhsheasmhach.

## `HStorefield`

#### `class HStoreField(**options)`

Réimse chun péirí luacha eochair a stóráil. Is é `dict` an cineál sonraí Python a úsáidtear. Caithfidh eochracha a bheith ina teaghráin, agus d'fhéadfadh luachanna a bheith ina teaghráin nó neamhaill (None i Python).

Chun an réimse seo a úsáid, beidh ort:

1. Cuir `django.contrib.postgres'` i d:setting: INSTALLED\_APPS.
2. [Set up the hstore extension](/ga/6.1/ref/contrib/postgres/operations/#create-postgresql-extensions) in
   PostgreSQL.

Feicfidh tú earráid mar ní féidir an cineál 'dict' a oiriúnú má scipeann tú an chéad chéim, nó cineál “hstore” ann má scipeann tú an dara ceann.

> **Note**
>
> Uaireanta d'fhéadfadh sé a bheith úsáideach na heochracha atá bailí do réimse ar leith a cheangal nó a shrianadh. Is féidir é seo a dhéanamh ag baint úsáide as an:class: ~django.contrib.postgres.validators.keysValidator.

### Ag fiosrú `hStorefield`

Chomh maith leis an gcumas ceist a dhéanamh de réir eochair, tá roinnt cuardaigh saincheaptha ar fáil do hStorefield\`.

Úsáidfimid an tsamhail sampla seo a leanas:

```
from django.contrib.postgres.fields import HStoreField
from django.db import models

class Dog(models.Model):
    name = models.CharField(max_length=200)
    data = HStoreField()

    def __str__(self):
        return self.name
```

#### Cuardaigh eochair

Chun fiosrú bunaithe ar eochair ar leith, is féidir leat an eochair sin a úsáid mar ainm an chuardaigh:

```pycon
>>> Dog.objects.create(name="Rufus", data={"breed": "labrador"})
>>> Dog.objects.create(name="Meg", data={"breed": "collie"})

>>> Dog.objects.filter(data__breed="collie")
<QuerySet [<Dog: Meg>]>
```

Is féidir leat cuardaigh eile a shlánú tar éis na príomhchuardaigh:

```pycon
>>> Dog.objects.filter(data__breed__contains="l")
<QuerySet [<Dog: Rufus>, <Dog: Meg>]>
```

nó bain úsáid as abairtí F () chun príomhluach a anótáil. Mar shampla:

```pycon
>>> from django.db.models import F
>>> rufus = Dog.objects.annotate(breed=F("data__breed"))[0]
>>> rufus.breed
'labrador'
```

Má tá an eochair is mian leat a cheistiú trí chomhraic le hainm cuardaigh eile, ní mór duit an cuardach: lookup: hstorefield.contains a úsáid ina ionad.

> **Note**
>
> Is féidir na hathruithe eochair a shlánú freisin le: :lookup: contains, :lookup: icontains, :lookup: endswith, :lookup: iendswith, :lookup: iexact, :lookup: regex, :lookup: iregex, :lookup: startswith, agus:lookup: Cuardaigh istartswith.

> **Warning**
>
> Ós rud é go bhféadfadh aon teaghrán a bheith ina eochair i luach hstore, léirmhínífear aon chuardach seachas iad siúd atá liostaithe thíos mar eochair chuardach. Ní ardaítear aon earráidí. Bí cúramach thar a bheith cúramach maidir le botúin clóscríobh, agus seiceáil i gcónaí go n-oibríonn do chuid

#### `Coimeád`

Cuirtear an cuardach: lookup: contains ar:class: ~django.contrib.postgres.fields.hStorefield. Is iad na rudaí a thugtar ar ais iad na rudaí ina bhfuil an `dict` tugtha de phéirí eochairluacha go léir sa réimse. Úsáideann sé an oibreoir SQL @\> . Mar shampla:

```pycon
>>> Dog.objects.create(name="Rufus", data={"breed": "labrador", "owner": "Bob"})
>>> Dog.objects.create(name="Meg", data={"breed": "collie", "owner": "Bob"})
>>> Dog.objects.create(name="Fred", data={})

>>> Dog.objects.filter(data__contains={"owner": "Bob"})
<QuerySet [<Dog: Rufus>, <Dog: Meg>]>

>>> Dog.objects.filter(data__contains={"breed": "collie"})
<QuerySet [<Dog: Meg>]>
```

#### `coinneáilteo_ag`

Is é seo an inbhéar den chuardach: lookup: conté \<hstorefield.contains\>\- is iad na rudaí a chuirtear ar ais iad na rudaí ina bhfuil na péirí luacha eochair ar an réad ina fho-thacar de na rudaí sa luach a rith. Úsáideann sé an oibreoir SQL `<@`. Mar shampla:

```pycon
>>> Dog.objects.create(name="Rufus", data={"breed": "labrador", "owner": "Bob"})
>>> Dog.objects.create(name="Meg", data={"breed": "collie", "owner": "Bob"})
>>> Dog.objects.create(name="Fred", data={})

>>> Dog.objects.filter(data__contained_by={"breed": "collie", "owner": "Bob"})
<QuerySet [<Dog: Meg>, <Dog: Fred>]>

>>> Dog.objects.filter(data__contained_by={"breed": "collie"})
<QuerySet [<Dog: Fred>]>
```

#### `a_eochair`

Tugann sé rudaí ar ais ina bhfuil an eochair a thugtar sna sonraí. Úsáideann an t-oibreoir SQL ? . Mar shampla:

```pycon
>>> Dog.objects.create(name="Rufus", data={"breed": "labrador"})
>>> Dog.objects.create(name="Meg", data={"breed": "collie", "owner": "Bob"})

>>> Dog.objects.filter(data__has_key="owner")
<QuerySet [<Dog: Meg>]>
```

#### `` `aon_eochair ``

Tugann sé rudaí ar ais ina bhfuil aon cheann de na heochracha a thugtar sna sonraí. Úsáideann an t-oibreoir SQL `? |`. Mar shampla:

```pycon
>>> Dog.objects.create(name="Rufus", data={"breed": "labrador"})
>>> Dog.objects.create(name="Meg", data={"owner": "Bob"})
>>> Dog.objects.create(name="Fred", data={})

>>> Dog.objects.filter(data__has_any_keys=["owner", "breed"])
<QuerySet [<Dog: Rufus>, <Dog: Meg>]>
```

#### `hais_eochair`

Tugann sé rudaí ar ais ina bhfuil na heochracha a thugtar go léir sna sonraí. Úsáideann an t-oibreoir SQL ? & . Mar shampla:

```pycon
>>> Dog.objects.create(name="Rufus", data={})
>>> Dog.objects.create(name="Meg", data={"breed": "collie", "owner": "Bob"})

>>> Dog.objects.filter(data__has_keys=["breed", "owner"])
<QuerySet [<Dog: Meg>]>
```

#### eochracha \`\`

Tugann sé rudaí ar ais ina bhfuil an raon eochracha an luach tugtha. Tabhair faoi deara nach ráthaítear go mbeidh an t-ordú iontaofa, mar sin tá an claochlú seo úsáideach go príomha le húsáid i gcomhar le cuardaigh ar:class: ~django.contrib.postgres.fields.arrayfield. Úsáideann sé an fheidhm SQL akeys () . Mar shampla:

```pycon
>>> Dog.objects.create(name="Rufus", data={"toy": "bone"})
>>> Dog.objects.create(name="Meg", data={"breed": "collie", "owner": "Bob"})

>>> Dog.objects.filter(data__keys__overlap=["breed", "toy"])
<QuerySet [<Dog: Rufus>, <Dog: Meg>]>
```

#### `luacha`

Tugann sé rudaí ar ais ina bhfuil an raon luachanna an luach a thugtar. Tabhair faoi deara nach ráthaítear go mbeidh an t-ordú iontaofa, mar sin tá an claochlú seo úsáideach go príomha le húsáid i gcomhar le cuardaigh ar:class: ~django.contrib.postgres.fields.arrayfield. Úsáideann sé an fheidhm SQL avals () . Mar shampla:

```pycon
>>> Dog.objects.create(name="Rufus", data={"breed": "labrador"})
>>> Dog.objects.create(name="Meg", data={"breed": "collie", "owner": "Bob"})

>>> Dog.objects.filter(data__values__contains=["collie"])
<QuerySet [<Dog: Meg>]>
```

## Réimsí Raon

Tá cúig chineál réimse réimse ann, a fhreagraíonn do na cineálacha raon ionsuite i PostgreSQL. Úsáidtear na réimsí seo chun raon luachanna a stóráil; mar shampla stampaí ama tosaigh agus deireadh imeachta, nó an raon aoiseanna a bhfuil gníomhaíocht oiriúnach dóibh.

Aistríonn gach ceann de na réim \<psycopg:adapt-range\>sí raon chuig: ref: psycopg Range earraí \`i Python, ach glacann siad le tuples mar ionchur mura bhfuil aon fhaisnéis teorainneacha riachtanach. Is é an réamhshocrú ceann íochtarach san áireamh, ceann uachtarach eisiata, is é sin \`\`\[)\` (féach doiciméadú PostgreSQL le haghaidh sonraí faoi [teorainneacha éagsúla](https://www.postgresql.org/docs/current/rangetypes.html#RANGETYPES-IO)). Is féidir na teorainneacha réamhshocraithe a athrú do réimsí raon neamh-scoite (:class: .DateTimeRangeField agus:class: .decimalRangeField) tríd an argóint default\_limits a úsáid.

> **PostgreSQL normalizes a range with no points to the empty range**
>
> A range with equal values specified for an included lower bound and an
> excluded upper bound, such as `Range(datetime.date(2005, 6, 21),
> datetime.date(2005, 6, 21))` or `[4, 4)`, has no points. PostgreSQL will
> normalize the value to empty when saving to the database, and the original
> bound values will be lost. See the [PostgreSQL documentation for details](https://www.postgresql.org/docs/current/rangetypes.html#RANGETYPES-IO).

### `Réimse Iomlána`

#### `class IntegerRangeField(**options)`

Stórálann sé raon sláimhreacha. Bunaithe ar: aicme: ~Django.db.Models.IntegerField. Léirítear ag `int4range` sa bhunachar sonraí agus `Django.db.backends.postgresql.psycopg_any.numericRange` i Python.

Beag beann ar na teorainneacha a shonraítear agus na sonraí á shábháil, filleann PostgreSQL raon i gcónaí i bhfoirm chanónach a chuimsíonn an ceann íochtarach agus a eisiann an ceann uachtarach, is é sin `[)`.

### `BigIntegerRangeField`

#### `class BigIntegerRangeField(**options)`

Stórálann sé raon sláimhreacha móra. Bunaithe ar a:class: ~Django.db.Models.BigIntegerField. Léirítear ag `int8range` sa bhunachar sonraí agus `Django.db.backends.postgresql.psycopg_any.numericRange` i Python.

Beag beann ar na teorainneacha a shonraítear agus na sonraí á shábháil, filleann PostgreSQL raon i gcónaí i bhfoirm chanónach a chuimsíonn an ceann íochtarach agus a eisiann an ceann uachtarach, is é sin `[)`.

### `Deimalrangefield`

#### `class DecimalRangeField(default_bounds='[)', **options)`

Stórálann sé raon luachanna pointe ar snámh. Bunaithe ar a:class: ~Django.db.Models.DecimalField. Léirítear ag `numrange` sa bhunachar sonraí agus `django.db.backends.postgreSQL.Psycopg_any.numericRange` i Python.

#### `default_bounds`

Roghnach. Luach teorainneacha \`\`le haghaidh ionchuir liosta agus tuple. Is é an réamhshocrú ceann íochtarach san áireamh, ceann uachtarach eisiata, is é sin \`\`\[)\` (féach doiciméadú PostgreSQL le haghaidh sonraí faoi [teorainneacha éagsúla](https://www.postgresql.org/docs/current/rangetypes.html#RANGETYPES-IO)). Ní úsáidtear `default_bounds` le haghaidh ionchuir `django.db.backends.postgresql.psycopg_any.numericRange`.

### `DataTimerangeField`

#### `class DateTimeRangeField(default_bounds='[)', **options)`

Stórálann sé raon stampaí ama. Bunaithe ar a:class: ~Django.db.Models.DateTimeField. Léirítear ag `tstzrange` sa bhunachar sonraí agus `django.db.backends.postgresql.psycopg_any.DateTimetzRange` i Python.

#### `default_bounds`

Roghnach. Luach teorainneacha \`\`le haghaidh ionchuir liosta agus tuple. Is é an réamhshocrú ceann íochtarach san áireamh, ceann uachtarach eisiata, is é sin \`\`\[)\` (féach doiciméadú PostgreSQL le haghaidh sonraí faoi [teorainneacha éagsúla](https://www.postgresql.org/docs/current/rangetypes.html#RANGETYPES-IO)). Ní úsáidtear `default_bounds` le haghaidh ionchuir `django.db.backends.postgresql.psycopg_any.DateTimetzRange`.

### `Daterangefield`

#### `class DateRangeField(**options)`

Stórálann sé raon dátaí. Bunaithe ar a:class: ~django.db.models.datefield. Léirítear ag `daterange` sa bhunachar sonraí agus `Django.db.backends.postgresql.psycopg_any.daterange` i Python.

Beag beann ar na teorainneacha a shonraítear agus na sonraí á shábháil, filleann PostgreSQL raon i gcónaí i bhfoirm chanónach a chuimsíonn an ceann íochtarach agus a eisiann an ceann uachtarach, is é sin `[)`.

### Réimsí Raon Fiosraithe

Tá roinnt cuardaigh agus claochruithe saincheaptha ann do réimsí raon. Tá siad ar fáil ar na réimsí thuas go léir, ach úsáidfimid an tsamhail sampla seo a leanas:

```
from django.contrib.postgres.fields import IntegerRangeField
from django.db import models

class Event(models.Model):
    name = models.CharField(max_length=200)
    ages = IntegerRangeField()
    start = models.DateTimeField()

    def __str__(self):
        return self.name
```

Úsáidfimid na rudaí samplacha seo a leanas freisin:

```pycon
>>> import datetime
>>> from django.utils import timezone
>>> now = timezone.now()
>>> Event.objects.create(name="Soft play", ages=(0, 10), start=now)
>>> Event.objects.create(
...     name="Pub trip", ages=(21, None), start=now - datetime.timedelta(days=1)
... )
```

agus `NumericRange`:

```
>>> from django.db.backends.postgresql.psycopg_any import NumericRange
```

#### Feidhmeanna srianta

Mar is amhlaidh le réimsí PostgreSQL eile, tá trí oibreoir srianta caighdeánacha ann: `contains`, contained\_by\` agus `overlap`, ag baint úsáide as na hoibreoirí SQL `@>`, `<@`, agus `&&` faoi seach.

##### `Coimeád`

```
>>> Event.objects.filter(ages__contains=NumericRange(4, 5))
<QuerySet [<Event: Soft play>]>
```

##### `coinneáilteo_ag`

```
>>> Event.objects.filter(ages__contained_by=NumericRange(0, 15))
<QuerySet [<Event: Soft play>]>
```

Tá an cuardach `contained_by` ar fáil freisin ar na cineálacha réimse neamh-raon: :class: ~django.db.models.smallAutofield, :class: ~django.db.models.autofield, :class: ~django.db.models.bigautofield, :class: ~django.db.models.smallintefield eld\`, :class: ~django.db.models.integerfield, :class: ~django.db.models.bigintegerfield, :class: ~django.db.models.decimalfield, :class: ~django.db.models.floatfield, :class: ~django.db.models.db.models.db.DateField, agus:aicme: ~Django.db.Models.DateTimeField. Mar shampla:

```pycon
>>> from django.db.backends.postgresql.psycopg_any import DateTimeTZRange
>>> Event.objects.filter(
...     start__contained_by=DateTimeTZRange(
...         timezone.now() - datetime.timedelta(hours=1),
...         timezone.now() + datetime.timedelta(hours=1),
...     ),
... )
<QuerySet [<Event: Soft play>]>
```

##### `` `overlap ``

```
>>> Event.objects.filter(ages__overlap=NumericRange(8, 12))
<QuerySet [<Event: Soft play>]>
```

#### feidhmeanna comparáide

Tacaíonn réimsí raon leis na cuardaigh chaighdeánacha: :lookup: lt, :lookup: gt, :lookup: lte agus:lookup: gte. Níl siad seo cabhrach go háirithe - déanann siad comparáid idir na teorainneacha íochtaracha ar dtús agus ansin na teorainneacha uachtaracha ach amháin más gá. Is í seo freisin an straitéis a úsáidtear chun ordú ag réimse raon. Is fearr na hoibreoirí comparáide raon sonracha a úsáid.

##### `` `go hiomlán_lt ``

Tá na raonta a thugtar ar ais níos lú ná an raon rith. Is é sin le rá, tá na pointí go léir sa raon ar ais níos lú ná iad siúd go léir sa raon rith.

```
>>> Event.objects.filter(ages__fully_lt=NumericRange(11, 15))
<QuerySet [<Event: Soft play>]>
```

##### `go hiomlán_gt`

Tá na raonta ar ais níos mó go docht ná an raon rith. Is é sin le rá, tá na pointí go léir sa raon ar ais níos mó ná iad siúd go léir sa raon rith.

```
>>> Event.objects.filter(ages__fully_gt=NumericRange(11, 15))
<QuerySet [<Event: Pub trip>]>
```

##### `` `not_lt ``

Níl aon phointí níos lú ná an raon rith sna raonta ar ais, is é sin an teorainn íochtarach den raon a thugtar ar ais an teorainn íochtarach den raon rith ar a laghad.

```
>>> Event.objects.filter(ages__not_lt=NumericRange(0, 15))
<QuerySet [<Event: Soft play>, <Event: Pub trip>]>
```

##### `` `ní gt ``

Níl aon phointí níos mó ná an raon rith sna raonta ar ais, is é sin an teorainn uachtarach den raon a thugtar ar ais an teorainn uachtarach den raon rith ar a mhéad.

```
>>> Event.objects.filter(ages__not_gt=NumericRange(3, 10))
<QuerySet [<Event: Soft play>]>
```

##### in aice láimhe \`\`

Roinneann na raonta a thugtar ar ais ceangailte leis an raon rith.

```
>>> Event.objects.filter(ages__adjacent_to=NumericRange(10, 21))
<QuerySet [<Event: Soft play>, <Event: Pub trip>]>
```

#### Fiosrú ag baint úsáide as na teorainneacha

Tacaíonn réimsí raon le roinnt cuardaigh bhreise.

##### tosaíonn leis \`\`

Tá an teorainn íochtarach tugtha ag rudaí ar ais. Is féidir é a shlabhraithe le cuardaigh bailí don bhunréimse.

```
>>> Event.objects.filter(ages__startswith=21)
<QuerySet [<Event: Pub trip>]>
```

##### Críochnaíonn \`\`

Tá an teorainn uachtarach tugtha ag rudaí ar ais. Is féidir é a shlabhraithe le cuardaigh bailí don bhunréimse.

```
>>> Event.objects.filter(ages__endswith=10)
<QuerySet [<Event: Soft play>]>
```

##### `isempty`

Is raonta folamh iad rudaí ar ais. Is féidir é a shlabhraithe le cuardaigh bailí do a:class: ~django.db.models.booleanfield.

```
>>> Event.objects.filter(ages__isempty=True)
<QuerySet []>
```

##### `` `lower_inc ``

Tugann sé rudaí ar ais a bhfuil teorainneacha íochtaracha cuimsitheacha nó eisiacha acu, ag brath ar an luach boolean a rith. Is féidir é a shlabhraithe le cuardaigh bailí do a:class: ~django.db.models.booleanfield.

```
>>> Event.objects.filter(ages__lower_inc=True)
<QuerySet [<Event: Soft play>, <Event: Pub trip>]>
```

##### inf\_níos ísle \`\`

Tugann sé rudaí ar ais a bhfuil srian níos ísle neamhtheoranta (gan teorainn) nó teoranta acu, ag brath ar an luach boolean a rith. Is féidir é a shlabhraithe le cuardaigh bailí do a:class: ~django.db.models.booleanfield.

```
>>> Event.objects.filter(ages__lower_inf=True)
<QuerySet []>
```

##### `uachtar_inc`

Tugann sé rudaí ar ais a bhfuil teorainneacha uachtaracha cuimsitheacha nó eisiacha acu, ag brath ar an luach boolean a rith. Is féidir é a shlabhraithe le cuardaigh bailí do a:class: ~django.db.models.booleanfield.

```
>>> Event.objects.filter(ages__upper_inc=True)
<QuerySet []>
```

##### `uachtar_inf`

Tugann sé ar ais rudaí a bhfuil srian uachtarach neamhtheoranta (gan teorainn) nó teoranta acu, ag brath ar an luach boolean a rith. Is féidir é a shlabhraithe le cuardaigh bailí do a:class: ~django.db.models.booleanfield.

```
>>> Event.objects.filter(ages__upper_inf=True)
<QuerySet [<Event: Pub trip>]>
```

### Sainmhíniú do chineálacha raon féin

Ceadaíonn PostgreSQL sainmhíniú ar chineálacha raon saincheaptha. Úsáideann forfheidhmithe réimse samhail agus foirme Django bunaicmí thíos, agus soláthraíonn `psycopg` a:func: ~psycopg:psycopg.types.range.register\_range chun cineálacha raon saincheaptha a úsáid.

#### `class RangeField(**options)`

Aicme bonn do réimsí raon samhail.

#### `base_field`

An rang réimse samhail le húsáid.

#### `range_type`

An cineál raon le húsáid.

#### `form_field`

An rang réimse foirm le húsáid. Ba chóir go mbeadh fo-aicme de:class: Django.Contrib.Postgres.Forms.BaseRangeField.

#### `class django.contrib.postgres.forms.BaseRangeField`

Aicme bonn do réimsí raon foirme.

#### `base_field`

An réimse foirme le húsáid.

#### `range_type`

An cineál raon le húsáid.

### Oibreoirí raon

#### `class RangeOperators`

\< <https://www.postgresql.org/docs/current/> functions-range.html #RANGE -OPERATORS-TABLE\>Soláthraíonn PostgreSQL sraith oibreoirí SQL is féidir a úsáid in éineacht leis na cineálacha sonraí raon (féach doiciméadú PostgreSQL le haghaidh sonraí iomlána oibreoirí raon \_). Tá an rang seo i gceist mar mhodh áisiúil chun clóscríobh a sheachaint. Forluíonn ainmneacha na n-oibreoirí le hainmneacha cuardaigh comhfhreagracha.

```python
class RangeOperators:
    EQUAL = "="
    NOT_EQUAL = "<>"
    CONTAINS = "@>"
    CONTAINED_BY = "<@"
    OVERLAPS = "&&"
    FULLY_LT = "<<"
    FULLY_GT = ">>"
    NOT_LT = "&>"
    NOT_GT = "&<"
    ADJACENT_TO = "-|-"
```

### RangeBoundary () abairtí

#### `class RangeBoundary(inclusive_lower=True, inclusive_upper=False)`

#### `inclusive_lower`

Má tá `True` (réamhshocraithe), tá an teorainn íochtarach cuimsitheach ``'['`, ar shlí eile is``' eisiach é ('.

#### `inclusive_upper`

Má tá `False` (réamhshocraithe), is é an teorainn uachtarach eisiach `') '`, ar shlí eile tá sé chuimsitheach\`\`'\] '.

Léiríonn abairt rangeboundary () teorainneacha na raon. Is féidir é a úsáid le feidhmeanna raon saincheaptha a raibh súil le teorainneacha, mar shampla chun sainmhíniú:class: ~django.contrib.postgres.restricints.ExclusionConstraint. \< <https://www.postgresql.org/> docs/current/rangetypes.html #RANGETYPES -INCLUSIVITY\>Féach .