PostgreSQL-specifika modellfält¶

Alla dessa fält är tillgängliga från modulen django.contrib.postgres.fields.

Indexering av dessa fält¶

Index och Field.db_index skapar båda ett B-tree-index, vilket inte är särskilt användbart vid frågor om komplexa datatyper. Index som GinIndex och GistIndex är bättre lämpade, även om indexvalet beror på de frågor som du använder. Generellt kan GiST vara ett bra val för range fields och HStoreField, och GIN kan vara till hjälp för ArrayField.

`ArrayField`¶

class ArrayField(base_field, size=None, **options)¶

Ett fält för lagring av listor med data. De flesta fälttyper kan användas, och du skickar en annan fältinstans som base_field. Du kan också ange en size. ArrayField kan nästlas för att lagra flerdimensionella matriser.

Om du ger fältet en default, se till att det är en callable som list (för en tom standard) eller en callable som returnerar en lista (t.ex. en funktion). Felaktig användning av default=[] skapar en föränderlig standard som delas mellan alla instanser av ArrayField.

base_field¶

Detta är ett nödvändigt argument.

Anger den underliggande datatypen och beteendet för arrayen. Det bör vara en instans av en underklass av Field. Det kan t.ex. vara en IntegerField eller en CharField. De flesta fälttyper är tillåtna, med undantag för de som hanterar relationsdata (ForeignKey, OneToOneField och ManyToManyField) och filfält (FileField och ImageField).

Det är möjligt att nesta array-fält - du kan ange en instans av ArrayField som base_field. Till exempel:

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

Omvandling av värden mellan databasen och modellen, validering av data och konfiguration samt serialisering delegeras till det underliggande basfältet.

size¶

Detta är ett valfritt argument.

Om den godkänns kommer matrisen att ha en maximal storlek enligt specifikationen. Detta kommer att skickas till databasen, även om PostgreSQL för närvarande inte verkställer begränsningen.

Observera

När du häckar ArrayField, oavsett om du använder parametern size eller inte, kräver PostgreSQL att matriserna är rektangulära:

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

Om oregelbundna former krävs, bör det underliggande fältet göras nollställbart och värdena fyllas i med None.

Fråga om `ArrayField`¶

Det finns ett antal anpassade lookups och transformationer för ArrayField. Vi kommer att använda följande exempelmodell:

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

`innehåller`¶

Uppslaget contains är åsidosatt på ArrayField. De returnerade objekten kommer att vara de där de värden som skickas är en delmängd av data. Den använder SQL-operatorn @>. Till exempel:

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

`innehålls_av`¶

Detta är motsatsen till contains - de objekt som returneras är de där data är en delmängd av de värden som skickats. Den använder SQL-operatorn <@. Till exempel:

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

`överlappning`¶

Returnerar objekt där data delar eventuella resultat med de värden som skickats. Använder SQL-operatorn &&. Till exempel:

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

Returnerar längden på arrayen. De uppslagningar som är tillgängliga efteråt är de som är tillgängliga för IntegerField. Till exempel:

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

Index omvandlas¶

Index transformerar index till matrisen. Alla icke-negativa heltal kan användas. Det blir inga fel om det överskrider size för matrisen. De uppslag som är tillgängliga efter transformationen är de från base_field. Till exempel:

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

Observera

PostgreSQL använder 1-baserad indexering för arrayfält när du skriver rå SQL. Men dessa index och de som används i slices använder 0-baserad indexering för att vara konsekvent med Python.

Skivtransformationer¶

Slice-transformationer tar en slice av matrisen. Två icke-negativa heltal kan användas, åtskilda av ett enda understreck. De uppslagsord som är tillgängliga efter transformationen ändras inte. Till exempel:

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

Observera

PostgreSQL använder 1-baserad indexering för arrayfält när du skriver rå SQL. Men dessa skivor och de som används i indexes använder 0-baserad indexering för att vara konsekvent med Python.

Flerdimensionella matriser med index och slices

PostgreSQL har något ganska esoteriskt beteende när man använder index och skivor på flerdimensionella matriser. Det kommer alltid att fungera att använda index för att nå ner till de slutliga underliggande uppgifterna, men de flesta andra skivor beter sig konstigt på databasnivå och kan inte stödjas på ett logiskt, konsekvent sätt av Django.

`HStoreField`¶

class HStoreField(**options)¶

Ett fält för lagring av nyckel-värde-par. Python-datatypen som används är en dict. Nycklar måste vara strängar och värden kan vara antingen strängar eller nollor (None i Python).

För att använda detta fält måste du:

Lägg till 'django.contrib.postgres' i din INSTALLED_APPS.
Sätta upp hstore-tillägget i PostgreSQL.

Du kommer att se ett fel som kan inte anpassa typen 'dict' om du hoppar över det första steget, eller typen "hstore" finns inte om du hoppar över det andra.

Observera

Ibland kan det vara användbart att kräva eller begränsa de nycklar som är giltiga för ett visst fält. Detta kan göras med hjälp av KeysValidator.

Förfrågan på `HStoreField`¶

Förutom möjligheten att ställa frågor efter nyckel finns det ett antal anpassade uppslagningar tillgängliga för HStoreField.

Vi kommer att använda följande exempelmodell:

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

Nyckeluppslagningar¶

Om du vill göra en sökning baserad på en viss nyckel kan du använda den nyckeln som uppslagsnamn:

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

Du kan kedja andra uppslagningar efter nyckeluppslagningar:

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

eller använda F()-uttryck för att kommentera ett nyckelvärde. Till exempel:

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

Om den nyckel som du vill söka på krockar med namnet på en annan uppslagning måste du använda hstorefield.contains istället.

Observera

Nyckelomvandlingar kan också kedjas med: contains, icontains, endswith, iendswith, iexact, regex, iregex, startswith och istartswith.

Varning

Eftersom vilken sträng som helst kan vara en nyckel i ett hstore-värde kommer alla andra uppslagningar än de som anges nedan att tolkas som en nyckeluppslagning. Inga felmeddelanden skickas ut. Var extra försiktig med skrivfel och kontrollera alltid att dina frågor fungerar som du tänkt dig.

`innehåller`¶

Uppslaget contains är åsidosatt på HStoreField. De returnerade objekten är de där den givna dict av nyckel-värdepar alla finns i fältet. Den använder SQL-operatorn @>. Till exempel:

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

`innehålls_av`¶

Detta är inversen av contains - de objekt som returneras är de där nyckel-värdeparen på objektet är en delmängd av dem i det värde som skickas. SQL-operatorn <@ används. Till exempel:

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

`har_nyckel`¶

Returnerar objekt där den angivna nyckeln finns i data. Använder SQL-operatorn ?. Till exempel:

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

`har_några_nycklar`¶

Returnerar objekt där någon av de angivna nycklarna finns i data. Använder SQL-operatorn ?|. Till exempel:

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

`har_nycklar`¶

Returnerar objekt där alla de angivna nycklarna finns i data. Använder SQL-operatorn ?&. Till exempel:

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

`nycklar`¶

Returnerar objekt där matrisen med nycklar är det angivna värdet. Observera att ordningen inte garanteras vara tillförlitlig, så denna transform är främst användbar för att använda i samband med uppslagningar på ArrayField. Använder SQL-funktionen akeys(). Till exempel:

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

`värden`¶

Returnerar objekt där matrisen av värden är det givna värdet. Observera att ordningen inte garanteras vara tillförlitlig, så denna transform är främst användbar för att använda i samband med uppslagningar på ArrayField. Använder SQL-funktionen avals(). Till exempel: avals():

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

Område Fält¶

Det finns fem fältfältstyper som motsvarar de inbyggda intervalltyperna i PostgreSQL. Dessa fält används för att lagra ett intervall av värden; till exempel start- och sluttidsstämplarna för en händelse eller åldersintervallet som en aktivitet är lämplig för.

Alla intervallfält översätts till psycopg Range objects i Python, men accepterar också tuples som inmatning om ingen gränsinformation är nödvändig. Standardvärdet är nedre gräns inkluderad, övre gräns utesluten, det vill säga [) (se PostgreSQL-dokumentationen för detaljer om olika gränser). Standardgränserna kan ändras för icke-diskreta intervallfält (DateTimeRangeField och DecimalRangeField) med hjälp av argumentet default_bounds.

PostgreSQL normaliserar ett intervall utan poäng till det tomma intervallet

Ett intervall med lika värden som anges för en inkluderad nedre gräns och en utesluten övre gräns, till exempel Range(datetime.date(2005, 6, 21), datetime.date(2005, 6, 21)) eller [4, 4), har inga poäng. PostgreSQL normaliserar värdet till tomt när det sparas i databasen och de ursprungliga bundna värdena kommer att gå förlorade. Se PostgreSQL-dokumentationen för detaljer.

`IntegerRangeField`¶

class IntegerRangeField(**options)¶

Lagrar ett intervall av heltal. Baserat på en IntegerField. Representeras av en int4range i databasen och en django.db.backends.postgresql.psycopg_any.NumericRange i Python.

Oavsett de gränser som anges när du sparar data returnerar PostgreSQL alltid ett intervall i en kanonisk form som inkluderar den nedre gränsen och utesluter den övre gränsen, det vill säga [).

`BigIntegerRangeField`¶

class BigIntegerRangeField(**options)¶

Lagrar ett intervall av stora heltal. Baserat på en BigIntegerField. Representeras av en int8range i databasen och en django.db.backends.postgresql.psycopg_any.NumericRange i Python.

`DecimalRangeField`¶

class DecimalRangeField(default_bounds='[)', **options)¶

Lagrar ett intervall av värden med flytande kommatecken. Baserat på en DecimalField. Representeras av en numrange i databasen och en django.db.backends.postgresql.psycopg_any.NumericRange i Python.

default_bounds¶: Valfritt. Värdet på bounds för list- och tupelingångar. Standardvärdet är nedre gränsen inkluderad, övre gränsen utesluten, det vill säga [) (se PostgreSQL-dokumentationen för detaljer om olika gränser). default_bounds används inte för django.db.backends.postgresql.psycopg_any.NumericRange inmatningar.

`DatumTimeRangeField`¶

class DateTimeRangeField(default_bounds='[)', **options)¶

Lagrar ett intervall av tidsstämplar. Baserat på en DateTimeField. Representeras av en tstzrange i databasen och en django.db.backends.postgresql.psycopg_any.DateTimeTZRange i Python.

default_bounds¶: Valfritt. Värdet på bounds för list- och tupelingångar. Standardvärdet är nedre gränsen inkluderad, övre gränsen utesluten, det vill säga [) (se PostgreSQL-dokumentationen för detaljer om olika gränser). default_bounds används inte för django.db.backends.postgresql.psycopg_any.DateTimeTZRange inmatningar.

`Datumintervallfält`¶

class DateRangeField(**options)¶

Lagrar ett intervall av datum. Baserat på en DateField. Representeras av en daterange i databasen och en django.db.backends.postgresql.psycopg_any.DateRange i Python.

Fråga efter intervallfält¶

Det finns ett antal anpassade uppslagningar och transformationer för intervallfält. De är tillgängliga för alla ovanstående fält, men vi kommer att använda följande exempelmodell:

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

Vi kommer också att använda följande exempelobjekt:

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

och NumericRange:

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

Inneslutningsfunktioner¶

Som med andra PostgreSQL-fält finns det tre standardinhållningsoperatörer: contains, contained_by och overlap, med hjälp av SQL-operatörerna @>, <@ och && respektive.

`innehåller`¶

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

`innehålls_av`¶

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

Uppslagningen contained_by är också tillgänglig för fälttyper som inte är intervall: SmallAutoField, AutoField, BigAutoField, SmallIntegerField, IntegerField, BigIntegerField.db.models.IntegerField`, BigIntegerField, DecimalField, FloatField, DateField, och DateTimeField. Till exempel:

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

`överlappning`¶

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

Jämförelsefunktioner¶

Range-fält stöder standarduppslagningar: lt, gt, lte och gte. Dessa är inte särskilt användbara - de jämför de nedre gränserna först och sedan de övre gränserna endast om det behövs. Detta är också den strategi som används för att beställa efter ett intervallfält. Det är bättre att använda de specifika operatörerna för jämförelse av intervall.

`fullständigt_lt`¶

De returnerade intervallen är strikt mindre än det passerade intervallet. Med andra ord är alla punkter i det returnerade intervallet mindre än alla punkter i det passerade intervallet.

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

`fullständigt_gt`¶

De returnerade intervallen är strikt större än det passerade intervallet. Med andra ord är alla punkter i det returnerade intervallet större än alla punkter i det passerade intervallet.

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

`not_lt`¶

De returnerade intervallen innehåller inte några punkter som är mindre än det passerade intervallet, dvs. den nedre gränsen för det returnerade intervallet är minst den nedre gränsen för det passerade intervallet.

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

`not_gt`¶

De returnerade intervallen innehåller inte några punkter som är större än det passerade intervallet, dvs. den övre gränsen för det returnerade intervallet är högst den övre gränsen för det passerade intervallet.

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

”intilliggande¶

De returnerade intervallen delar en bindning med det passerade intervallet.

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

Förfrågan med hjälp av gränserna¶

Range-fält stöder flera extra uppslagningar.

`börjar med`¶

Returnerade objekt har den angivna nedre gränsen. Kan kedjas till giltiga uppslagningar för basfältet.

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

`slutar med`¶

Returnerade objekt har den angivna övre gränsen. Kan kedjas till giltiga uppslagningar för basfältet.

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

`isempty`¶

Returnerade objekt är tomma intervall. Kan kedjas till giltiga uppslagningar för en BooleanField.

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

`lägre_inc`¶

Returnerar objekt som har inkluderande eller exklusiva nedre gränser, beroende på det booleska värdet som skickas. Kan kedjas till giltiga uppslagningar för en BooleanField.

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

`lägre_inf`¶

Returnerar objekt som har obegränsad (oändlig) eller begränsad nedre gräns, beroende på det booleska värdet som skickas. Kan kedjas till giltiga uppslagningar för en BooleanField.

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

`övre_inc`¶

Returnerar objekt som har inkluderande eller exklusiva övre gränser, beroende på det booleska värdet som skickas. Kan kedjas till giltiga uppslagningar för en BooleanField.

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

`övre_inf`¶

Returnerar objekt som har obegränsad (oändlig) eller begränsad övre gräns, beroende på det booleska värdet som skickas. Kan kedjas till giltiga uppslagningar för en BooleanField.

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

Definiera dina egna sortimentstyper¶

PostgreSQL tillåter definitionen av anpassade intervalltyper. Djangos modell- och formulärfältimplementeringar använder basklasser nedan, och psycopg tillhandahåller en register_range() för att tillåta användning av anpassade intervalltyper.

class RangeField(**options)¶

Basklass för modellområdesfält.

base_field¶: Den modellfältklass som ska användas.

range_type¶: Den intervalltyp som ska användas.

form_field¶: Klassen för formulärfältet som ska användas. Bör vara en underklass av django.contrib.postgres.forms.BaseRangeField.

class django.contrib.postgres.forms.BaseRangeField¶

Basklass för fält i formulärintervall.

base_field¶: Det formulärfält som ska användas.

range_type¶: Den intervalltyp som ska användas.

Operatörer inom området¶

class RangeOperators¶

PostgreSQL tillhandahåller en uppsättning SQL-operatörer som kan användas tillsammans med intervalldatatyperna (se PostgreSQL-dokumentationen för fullständig information om intervalloperatörer). Denna klass är tänkt som en bekväm metod för att undvika skrivfel. Operatörsnamnen överlappar namnen på motsvarande uppslagningar.

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

RangeBoundary() uttryck¶

class RangeBoundary(inclusive_lower=True, inclusive_upper=False)¶

inclusive_lower¶: Om True (standard), är den nedre gränsen inkluderande '[', annars är den exklusiv '('.

inclusive_upper¶: Om False (standard), är den övre gränsen exklusiv ')', annars är den inkluderande ']'.

Ett RangeBoundary()-uttryck representerar intervallgränserna. Det kan användas med anpassade intervallfunktioner som förväntade gränser, till exempel för att definiera ExclusionConstraint. Se PostgreSQL-dokumentationen för fullständiga detaljer.

PostgreSQL-specifika modellfält¶

Indexering av dessa fält¶

ArrayField¶

Fråga om ArrayField¶

innehåller¶

innehålls_av¶

överlappning¶

len¶

Index omvandlas¶

Skivtransformationer¶

HStoreField¶

Förfrågan på HStoreField¶

Nyckeluppslagningar¶

innehåller¶

innehålls_av¶

har_nyckel¶

har_några_nycklar¶

har_nycklar¶

nycklar¶

värden¶

Område Fält¶

IntegerRangeField¶

BigIntegerRangeField¶

DecimalRangeField¶

DatumTimeRangeField¶

Datumintervallfält¶

Fråga efter intervallfält¶

Inneslutningsfunktioner¶

innehåller¶

innehålls_av¶

överlappning¶

Jämförelsefunktioner¶

fullständigt_lt¶

fullständigt_gt¶

not_lt¶

not_gt¶

”intilliggande¶

Förfrågan med hjälp av gränserna¶

börjar med¶

slutar med¶

isempty¶

lägre_inc¶

lägre_inf¶

övre_inc¶

övre_inf¶

Definiera dina egna sortimentstyper¶

Operatörer inom området¶

RangeBoundary() uttryck¶

Additional Information

Support Django!

Contents

Getting help

Download:

`ArrayField`¶

Fråga om `ArrayField`¶

`innehåller`¶

`innehålls_av`¶

`överlappning`¶

`len`¶

`HStoreField`¶

Förfrågan på `HStoreField`¶

`innehåller`¶

`innehålls_av`¶

`har_nyckel`¶

`har_några_nycklar`¶

`har_nycklar`¶

`nycklar`¶

`värden`¶

`IntegerRangeField`¶

`BigIntegerRangeField`¶

`DecimalRangeField`¶

`DatumTimeRangeField`¶

`Datumintervallfält`¶

`innehåller`¶

`innehålls_av`¶

`överlappning`¶

`fullständigt_lt`¶

`fullständigt_gt`¶

`not_lt`¶

`not_gt`¶

`börjar med`¶

`slutar med`¶

`isempty`¶

`lägre_inc`¶

`lägre_inf`¶

`övre_inc`¶

`övre_inf`¶