djangodocs

Django 5.2
Gaeilge
Documentation contents

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 and Field.db_index both create a B-tree index, which isn't particularly helpful when querying complex data types. Indexes such as GinIndex and 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 and HStoreField, and GIN may be helpful for 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. For example, it could be an IntegerField or a CharField. Most field types are permitted, with the exception of those handling relational data (ForeignKey, OneToOneField and ManyToManyField) and file fields (FileField and ImageField).

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

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

Ag fiosrú Arrayfield

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

Code
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:

Python console
>>> 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:

Python console
>>> 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:

Python console
>>> 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:

Python console
>>> 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:

Python console
>>> 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 []>

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:

Python console
>>> 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>]>

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

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:

Code
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:

Python console
>>> 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:

Python console
>>> 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:

Python console
>>> 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.

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:

Python console
>>> 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:

Python console
>>> 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:

Python console
>>> 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:

Python console
>>> 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:

Python console
>>> 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:

Python console
>>> 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:

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

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

Code
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:

Python console
>>> 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:

Code
>>> 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
Code
>>> Event.objects.filter(ages__contains=NumericRange(4, 5))
<QuerySet [<Event: Soft play>]>
coinneáilteo_ag
Code
>>> 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:

Python console
>>> 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
Code
>>> 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.

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

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

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

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

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

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

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

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

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

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

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

Code
>>> 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 `doiciméadú PostgreSQL le haghaidh na sonraí iomlána`_.

View as Markdown Edit this page on GitHub Official version