--- title: "PostgreSQL-specifika modellfält" version: 6.1 locale: sv source: https://docs.djangoproject.com/sv/6.1/ref/contrib/postgres/fields/ canonical: https://djangodocs.dev/sv/6.1/ref/contrib/postgres/fields/ --- # PostgreSQL-specifika modellfält Alla dessa fält är tillgängliga från modulen `django.contrib.postgres.fields`. ## Indexering av dessa fält [`Index`](/sv/6.1/ref/models/indexes/#django.db.models.Index) och [`Field.db_index`](/sv/6.1/ref/models/fields/#django.db.models.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`](/sv/6.1/ref/contrib/postgres/indexes/#django.contrib.postgres.indexes.GinIndex) och [`GistIndex`](/sv/6.1/ref/contrib/postgres/indexes/#django.contrib.postgres.indexes.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](#range-fields) och [`HStoreField`](#django.contrib.postgres.fields.HStoreField), och GIN kan vara till hjälp för [`ArrayField`](#django.contrib.postgres.fields.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`](#django.contrib.postgres.fields.ArrayField.base_field). Du kan också ange en [`size`](#django.contrib.postgres.fields.ArrayField.size). `ArrayField` kan nästlas för att lagra flerdimensionella matriser. Om du ger fältet en [`default`](/sv/6.1/ref/models/fields/#django.db.models.Field.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`](/sv/6.1/ref/models/fields/#django.db.models.Field). Det kan t.ex. vara en [`IntegerField`](/sv/6.1/ref/models/fields/#django.db.models.IntegerField) eller en [`CharField`](/sv/6.1/ref/models/fields/#django.db.models.CharField). De flesta fälttyper är tillåtna, med undantag för de som hanterar relationsdata ([`ForeignKey`](/sv/6.1/ref/models/fields/#django.db.models.ForeignKey), [`OneToOneField`](/sv/6.1/ref/models/fields/#django.db.models.OneToOneField) och [`ManyToManyField`](/sv/6.1/ref/models/fields/#django.db.models.ManyToManyField)) och filfält ([`FileField`](/sv/6.1/ref/models/fields/#django.db.models.FileField) och [`ImageField`](/sv/6.1/ref/models/fields/#django.db.models.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. > **Note** > > 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`](#django.contrib.postgres.fields.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`](/sv/6.1/ref/models/querysets/#std-fieldlookup-contains) är åsidosatt på [`ArrayField`](#django.contrib.postgres.fields.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: ```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"]) , ]> >>> Post.objects.filter(tags__contains=["django"]) , ]> >>> Post.objects.filter(tags__contains=["django", "thoughts"]) ]> ``` #### `innehålls_av` Detta är motsatsen till [`contains`](#std-fieldlookup-arrayfield.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: ```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"]) , ]> >>> Post.objects.filter(tags__contained_by=["thoughts", "django", "tutorial"]) , , ]> ``` #### `överlappning` Returnerar objekt där data delar eventuella resultat med de värden som skickats. Använder SQL-operatorn `&&`. Till exempel: ```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"]) , ]> >>> Post.objects.filter(tags__overlap=["thoughts", "tutorial"]) , , ]> >>> Post.objects.filter(tags__overlap=Post.objects.values_list("tags")) , , ]> ``` #### `len` Returnerar längden på arrayen. De uppslagningar som är tillgängliga efteråt är de som är tillgängliga för [`IntegerField`](/sv/6.1/ref/models/fields/#django.db.models.IntegerField). Till exempel: ```pycon >>> Post.objects.create(name="First post", tags=["thoughts", "django"]) >>> Post.objects.create(name="Second post", tags=["thoughts"]) >>> Post.objects.filter(tags__len=1) ]> ``` #### Index omvandlas Index transformerar index till matrisen. Alla icke-negativa heltal kan användas. Det blir inga fel om det överskrider [`size`](#django.contrib.postgres.fields.ArrayField.size) för matrisen. De uppslag som är tillgängliga efter transformationen är de från [`base_field`](#django.contrib.postgres.fields.ArrayField.base_field). Till exempel: ```pycon >>> Post.objects.create(name="First post", tags=["thoughts", "django"]) >>> Post.objects.create(name="Second post", tags=["thoughts"]) >>> Post.objects.filter(tags__0="thoughts") , ]> >>> Post.objects.filter(tags__1__iexact="Django") ]> >>> Post.objects.filter(tags__276="javascript") ``` > **Note** > > 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`](#std-fieldlookup-arrayfield.slice) 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: ```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"]) , ]> >>> Post.objects.filter(tags__0_2__contains=["thoughts"]) , ]> ``` > **Note** > > 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`](#std-fieldlookup-arrayfield.index) 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: 1. Lägg till `'django.contrib.postgres'` i din [`INSTALLED_APPS`](/sv/6.1/ref/settings/#std-setting-INSTALLED_APPS). 2. [Sätta upp hstore-tillägget](/sv/6.1/ref/contrib/postgres/operations/#create-postgresql-extensions) 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. > **Note** > > 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`](/sv/6.1/ref/contrib/postgres/validators/#django.contrib.postgres.validators.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: ```pycon >>> Dog.objects.create(name="Rufus", data={"breed": "labrador"}) >>> Dog.objects.create(name="Meg", data={"breed": "collie"}) >>> Dog.objects.filter(data__breed="collie") ]> ``` Du kan kedja andra uppslagningar efter nyckeluppslagningar: ```pycon >>> Dog.objects.filter(data__breed__contains="l") , ]> ``` eller använda `F()`-uttryck för att kommentera ett nyckelvärde. Till exempel: ```pycon >>> 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`](#std-fieldlookup-hstorefield.contains) istället. > **Note** > > Nyckelomvandlingar kan också kedjas med: [`contains`](/sv/6.1/ref/models/querysets/#std-fieldlookup-contains), [`icontains`](/sv/6.1/ref/models/querysets/#std-fieldlookup-icontains), [`endswith`](/sv/6.1/ref/models/querysets/#std-fieldlookup-endswith), [`iendswith`](/sv/6.1/ref/models/querysets/#std-fieldlookup-iendswith), [`iexact`](/sv/6.1/ref/models/querysets/#std-fieldlookup-iexact), [`regex`](/sv/6.1/ref/models/querysets/#std-fieldlookup-regex), [`iregex`](/sv/6.1/ref/models/querysets/#std-fieldlookup-iregex), [`startswith`](/sv/6.1/ref/models/querysets/#std-fieldlookup-startswith) och [`istartswith`](/sv/6.1/ref/models/querysets/#std-fieldlookup-istartswith). > **Warning** > > 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`](/sv/6.1/ref/models/querysets/#std-fieldlookup-contains) är åsidosatt på [`HStoreField`](#django.contrib.postgres.fields.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: ```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"}) , ]> >>> Dog.objects.filter(data__contains={"breed": "collie"}) ]> ``` #### `innehålls_av` Detta är inversen av [`contains`](#std-fieldlookup-hstorefield.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: ```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"}) , ]> >>> Dog.objects.filter(data__contained_by={"breed": "collie"}) ]> ``` #### `har_nyckel` Returnerar objekt där den angivna nyckeln finns i data. Använder SQL-operatorn `?`. Till exempel: ```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") ]> ``` #### `har_några_nycklar` Returnerar objekt där någon av de angivna nycklarna finns i data. Använder SQL-operatorn `?|`. Till exempel: ```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"]) , ]> ``` #### `har_nycklar` Returnerar objekt där alla de angivna nycklarna finns i data. Använder SQL-operatorn `?&`. Till exempel: ```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"]) ]> ``` #### `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`](#django.contrib.postgres.fields.ArrayField). Använder SQL-funktionen `akeys()`. Till exempel: ```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"]) , ]> ``` #### `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`](#django.contrib.postgres.fields.ArrayField). Använder SQL-funktionen `avals()`. Till exempel: `avals()`: ```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"]) ]> ``` ## 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](https://www.psycopg.org/psycopg3/docs/basic/pgtypes.html#adapt-range) 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](https://www.postgresql.org/docs/current/rangetypes.html#RANGETYPES-IO)). Standardgränserna kan ändras för icke-diskreta intervallfält ([`DateTimeRangeField`](#django.contrib.postgres.fields.DateTimeRangeField) och [`DecimalRangeField`](#django.contrib.postgres.fields.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](https://www.postgresql.org/docs/current/rangetypes.html#RANGETYPES-IO). ### `IntegerRangeField` #### `class IntegerRangeField(**options)` Lagrar ett intervall av heltal. Baserat på en [`IntegerField`](/sv/6.1/ref/models/fields/#django.db.models.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`](/sv/6.1/ref/models/fields/#django.db.models.BigIntegerField). Representeras av en `int8range` 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 `[)`. ### `DecimalRangeField` #### `class DecimalRangeField(default_bounds='[)', **options)` Lagrar ett intervall av värden med flytande kommatecken. Baserat på en [`DecimalField`](/sv/6.1/ref/models/fields/#django.db.models.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](https://www.postgresql.org/docs/current/rangetypes.html#RANGETYPES-IO)). `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`](/sv/6.1/ref/models/fields/#django.db.models.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](https://www.postgresql.org/docs/current/rangetypes.html#RANGETYPES-IO)). `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`](/sv/6.1/ref/models/fields/#django.db.models.DateField). Representeras av en `daterange` i databasen och en `django.db.backends.postgresql.psycopg_any.DateRange` 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 `[)`. ### 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: ```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) ... ) ``` 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)) ]> ``` ##### `innehålls_av` ``` >>> Event.objects.filter(ages__contained_by=NumericRange(0, 15)) ]> ``` Uppslagningen `contained_by` är också tillgänglig för fälttyper som inte är intervall: [`SmallAutoField`](/sv/6.1/ref/models/fields/#django.db.models.SmallAutoField), [`AutoField`](/sv/6.1/ref/models/fields/#django.db.models.AutoField), [`BigAutoField`](/sv/6.1/ref/models/fields/#django.db.models.BigAutoField), [`SmallIntegerField`](/sv/6.1/ref/models/fields/#django.db.models.SmallIntegerField), [`IntegerField`](/sv/6.1/ref/models/fields/#django.db.models.IntegerField), [`BigIntegerField`](/sv/6.1/ref/models/fields/#django.db.models.BigIntegerField).db.models.IntegerField\`, [`BigIntegerField`](/sv/6.1/ref/models/fields/#django.db.models.BigIntegerField), [`DecimalField`](/sv/6.1/ref/models/fields/#django.db.models.DecimalField), [`FloatField`](/sv/6.1/ref/models/fields/#django.db.models.FloatField), [`DateField`](/sv/6.1/ref/models/fields/#django.db.models.DateField), och [`DateTimeField`](/sv/6.1/ref/models/fields/#django.db.models.DateTimeField). Till exempel: ```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), ... ), ... ) ]> ``` ##### `överlappning` ``` >>> Event.objects.filter(ages__overlap=NumericRange(8, 12)) ]> ``` #### Jämförelsefunktioner Range-fält stöder standarduppslagningar: [`lt`](/sv/6.1/ref/models/querysets/#std-fieldlookup-lt), [`gt`](/sv/6.1/ref/models/querysets/#std-fieldlookup-gt), [`lte`](/sv/6.1/ref/models/querysets/#std-fieldlookup-lte) och [`gte`](/sv/6.1/ref/models/querysets/#std-fieldlookup-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)) ]> ``` ##### `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)) ]> ``` ##### `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)) , ]> ``` ##### `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)) ]> ``` ##### ”intilliggande De returnerade intervallen delar en bindning med det passerade intervallet. ``` >>> Event.objects.filter(ages__adjacent_to=NumericRange(10, 21)) , ]> ``` #### 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) ]> ``` ##### `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) ]> ``` ##### `isempty` Returnerade objekt är tomma intervall. Kan kedjas till giltiga uppslagningar för en [`BooleanField`](/sv/6.1/ref/models/fields/#django.db.models.BooleanField). ``` >>> Event.objects.filter(ages__isempty=True) ``` ##### `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`](/sv/6.1/ref/models/fields/#django.db.models.BooleanField). ``` >>> Event.objects.filter(ages__lower_inc=True) , ]> ``` ##### `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`](/sv/6.1/ref/models/fields/#django.db.models.BooleanField). ``` >>> Event.objects.filter(ages__lower_inf=True) ``` ##### `ö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`](/sv/6.1/ref/models/fields/#django.db.models.BooleanField). ``` >>> Event.objects.filter(ages__upper_inc=True) ``` ##### `ö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`](/sv/6.1/ref/models/fields/#django.db.models.BooleanField). ``` >>> Event.objects.filter(ages__upper_inf=True) ]> ``` ### 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()`](https://www.psycopg.org/psycopg3/docs/basic/pgtypes.html#psycopg.types.range.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`](#django.contrib.postgres.fields.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](https://www.postgresql.org/docs/current/functions-range.html#RANGE-OPERATORS-TABLE)). Denna klass är tänkt som en bekväm metod för att undvika skrivfel. Operatörsnamnen överlappar namnen på motsvarande uppslagningar. ```python 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`](/sv/6.1/ref/contrib/postgres/constraints/#django.contrib.postgres.constraints.ExclusionConstraint). Se [PostgreSQL-dokumentationen för fullständiga detaljer](https://www.postgresql.org/docs/current/rangetypes.html#RANGETYPES-INCLUSIVITY).