---
title: "GIS QuerySet API-referens"
version: 5.2
locale: sv
source: https://docs.djangoproject.com/sv/5.2/ref/contrib/gis/geoquerysets/
canonical: https://djangodocs.dev/sv/5.2/ref/contrib/gis/geoquerysets/
---
# GIS QuerySet API-referens

## Rumsliga uppslagningar

De rumsliga uppslagningarna i detta avsnitt är tillgängliga för [`GeometryField`](/sv/5.2/ref/contrib/gis/model-api/#django.contrib.gis.db.models.GeometryField) och [`RasterField`](/sv/5.2/ref/contrib/gis/model-api/#django.contrib.gis.db.models.RasterField).

För en introduktion, se [spatial lookups introduction](/sv/5.2/ref/contrib/gis/db-api/#spatial-lookups-intro).  En översikt över vilka uppslagningar som är kompatibla med en viss spatial backend finns i [spatial lookup compatibility table](/sv/5.2/ref/contrib/gis/db-api/#spatial-lookup-compatibility).

### Uppslagningar med raster

Alla exempel i referensen nedan ges för geometriska fält och inmatningar, men uppslagningarna kan användas på samma sätt med raster på båda sidor. När en lookup inte stöder rasterinmatning konverteras inmatningen automatiskt till en geometri där så behövs med hjälp av funktionen [ST\_Polygon](https://postgis.net/docs/RT_ST_Polygon.html). Se även [introduktion till rasteruppslagningar](/sv/5.2/ref/contrib/gis/db-api/#spatial-lookup-raster).

De databasoperatörer som används vid uppslagningarna kan delas in i tre kategorier:

- Native raster support `N`: operatören accepterar raster på båda sidor av lookupen och rasterdata kan blandas med geometridata.
- Bilateralt rasterstöd `B`: operatören stöder raster endast om båda sidor av uppslagningen får rasterdata. Rasterdata konverteras automatiskt till geometrier för blandade uppslagningar.
- Stöd för geometriomvandling `C`. Lookupen har inget inbyggt stöd för raster, alla rasterdata konverteras automatiskt till geometrier.

Exemplen nedan visar SQL-motsvarigheten för uppslagningarna i de olika typerna av rasterstöd. Samma mönster gäller för alla spatiala uppslagningar.

| Case | Uppslag | SQL-ekvivalent |
| --- | --- | --- |
| N, B | `rast__innehåller=rst` | `ST_Contains(rast, rst)` |
| N, B | `rast__1__contains=(rst, 2)` | `ST_Contains(rast, 1, rst, 2)` |
| B, C | `rast__innehåller=geom` | `ST_Contains(ST_Polygon(rast), geom)` |
| B, C | `rast__1__innehåller=geom` | `ST_Contains(ST_Polygon(rast, 1), geom)` |
| B, C | `poly__innehåller=rst` | `ST_Contains(poly, ST_Polygon(rst))` |
| B, C | `poly__contains=(rst, 1)` | `ST_Contains(poly, ST_Polygon(rst, 1))` |
| C | `rast__korsningar=rst` | `ST_Crosses(ST_Polygon(rast), ST_Polygon(rst))` |
| C | `rast__1__korsningar=(rst, 2)` | `ST_Crosses(ST_Polygon(rast, 1), ST_Polygon(rst, 2))` |
| C | `rast__korsningar=geom` | `ST_Crosses(ST_Polygon(rast), geom)` |
| C | `poly__kors=rst` | `ST_Crosses(poly, ST_Polygon(rst))` |

Rumsliga uppslagningar med raster stöds endast för PostGIS-backends (benämns som PGRaster i detta avsnitt).

### `bbcontains`

*Tillgänglighet*: [PostGIS](https://postgis.net/docs/ST_Geometry_Contain.html), MariaDB, MySQL, SpatiaLite, PGRaster (inbyggd)

Testar om geometrins eller rasterfältets begränsningsbox helt och hållet innehåller uppslagsgeometrins begränsningsbox.

Exempel:

```
Zipcode.objects.filter(poly__bbcontains=geom)
```

| Backend | SQL-ekvivalent |
| --- | --- |
| PostGIS | `poly ~ geom` |
| MariaDB | `MBRContains(poly, geom)` |
| MySQL | `MBRContains(poly, geom)` |
| SpatiaLite | `MbrInnehåller(poly, geom)` |

### `bboverlaps`

*Tillgänglighet*: [PostGIS](https://postgis.net/docs/geometry_overlaps.html), MariaDB, MySQL, SpatiaLite, PGRaster (inbyggd)

Testar om geometrifältets avgränsningsbox överlappar uppslagsgeometrins avgränsningsbox.

Exempel:

```
Zipcode.objects.filter(poly__bboverlaps=geom)
```

| Backend | SQL-ekvivalent |
| --- | --- |
| PostGIS | `poly && geom` |
| MariaDB | `MBROverlaps(poly, geom)` |
| MySQL | `MBROverlaps(poly, geom)` |
| SpatiaLite | `MbrOverlaps(poly, geom)` |

### `innehållen`

*Tillgänglighet*: [PostGIS](https://postgis.net/docs/ST_Geometry_Contained.html), MariaDB, MySQL, SpatiaLite, PGRaster (inbyggd)

Testar om geometrifältets avgränsningsbox är helt innesluten i uppslagsgeometrins avgränsningsbox.

Exempel:

```
Zipcode.objects.filter(poly__contained=geom)
```

| Backend | SQL-ekvivalent |
| --- | --- |
| PostGIS | `poly @ geom` |
| MariaDB | `MBRInom(poly, geom)` |
| MySQL | `MBRInom(poly, geom)` |
| SpatiaLite | `MbrInom(poly, geom)` |

### `innehåller`

*Tillgänglighet*: [PostGIS](https://postgis.net/docs/ST_Contains.html), Oracle, MariaDB, MySQL, SpatiaLite, PGRaster (Bilateral)

Testar om geometrifältet rumsligt innehåller uppslagsgeometrin.

Exempel:

```
Zipcode.objects.filter(poly__contains=geom)
```

| Backend | SQL-ekvivalent |
| --- | --- |
| PostGIS | `ST_Contains(poly, geom)` |
| Oracle | `SDO_CONTAINS(poly, geom)` |
| MariaDB | `ST_Contains(poly, geom)` |
| MySQL | `ST_Contains(poly, geom)` |
| SpatiaLite | `Innehåller(poly, geom)` |

### `innehåller_riktigt`

*Tillgänglighet*: [PostGIS](https://postgis.net/docs/ST_ContainsProperly.html), PGRaster (Bilateral)

Returnerar true om uppslagsgeometrin skär geometrins insida, men inte dess gräns (eller utsida).

Exempel:

```
Zipcode.objects.filter(poly__contains_properly=geom)
```

| Backend | SQL-ekvivalent |
| --- | --- |
| PostGIS | `ST_ContainsProperly(poly, geom)` |

### ”täckt av

*Tillgänglighet*: [PostGIS](https://postgis.net/docs/ST_CoveredBy.html), Oracle, MySQL, PGRaster (Bilateral), SpatiaLite

Testar om ingen punkt i geometrifältet ligger utanför lookup-geometrin. [^3] \_

Exempel:

```
Zipcode.objects.filter(poly__coveredby=geom)
```

| Backend | SQL-ekvivalent |
| --- | --- |
| PostGIS | `ST_CoveredBy(poly, geom)` |
| Oracle | `SDO_COVEREDBY(poly, geom)` |
| MySQL | `MBRCoveredBy(poly, geom)` |
| SpatiaLite | `CoveredBy(poly, geom)` |

> **Changed in Django 5.2**
>
> Stöd för MySQL har lagts till.

### `överdrag`

*Tillgänglighet*: [PostGIS](https://postgis.net/docs/ST_Covers.html), Oracle, MySQL, PGRaster (Bilateral), SpatiaLite

Testar om ingen punkt i uppslagsgeometrin ligger utanför geometrifältet. [^3] \_

Exempel:

```
Zipcode.objects.filter(poly__covers=geom)
```

| Backend | SQL-ekvivalent |
| --- | --- |
| PostGIS | `ST_Covers(poly, geom)` |
| Oracle | `SDO_COVERS(poly, geom)` |
| MySQL | `MBRCovers(poly, geom)` |
| SpatiaLite | `Täckningar(poly, geom)` |

> **Changed in Django 5.2**
>
> Stöd för MySQL har lagts till.

### `korsningar`

*Tillgänglighet*: postGIS \<[https://postgis.net/docs/ST\_Crosses.html](https://postgis.net/docs/ST_Crosses.html)\>\`\_\_, MariaDB, MySQL, SpatiaLite, PGRaster (konvertering)

Testar om geometrifältet rumsligt korsar lookup-geometrin.

Exempel:

```
Zipcode.objects.filter(poly__crosses=geom)
```

| Backend | SQL-ekvivalent |
| --- | --- |
| PostGIS | `ST_Crosses(poly, geom)` |
| MariaDB | `ST_Crosses(poly, geom)` |
| MySQL | `ST_Crosses(poly, geom)` |
| SpatiaLite | `Korsningar(poly, geom)` |

### `disjunkt`

*Tillgänglighet*: [PostGIS](https://postgis.net/docs/ST_Disjoint.html), Oracle, MariaDB, MySQL, SpatiaLite, PGRaster (Bilateral)

Testar om geometrifältet är rumsligt åtskilt från uppslagsgeometrin.

Exempel:

```
Zipcode.objects.filter(poly__disjoint=geom)
```

| Backend | SQL-ekvivalent |
| --- | --- |
| PostGIS | `ST_Disjoint(poly, geom)` |
| Oracle | `SDO_GEOM.RELATE(poly, 'DISJOINT', geom, 0,05)` |
| MariaDB | `ST_Disjoint(poly, geom)` |
| MySQL | `ST_Disjoint(poly, geom)` |
| SpatiaLite | `Disjoint(poly, geom)` |

### `likvärdiga`

*Tillgänglighet*: [PostGIS](https://postgis.net/docs/ST_Equals.html), Oracle, MariaDB, MySQL, SpatiaLite, PGRaster (Konvertering)

Testar om geometrifältet är rumsligt lika med uppslagsgeometrin.

Exempel:

```
Zipcode.objects.filter(poly__equals=geom)
```

| Backend | SQL-ekvivalent |
| --- | --- |
| PostGIS | `ST_Equals(poly, geom)` |
| Oracle | `SDO_EQUAL(poly, geom)` |
| MariaDB | `ST_Equals(poly, geom)` |
| MySQL | `ST_Equals(poly, geom)` |
| SpatiaLite | `Equals(poly, geom)` |

### `exact`, `same_as`

*Tillgänglighet*: [PostGIS](https://postgis.net/docs/ST_Geometry_Same.html), Oracle, MariaDB, MySQL, SpatiaLite, PGRaster (Bilateral)

Testar om geometrifältet är ”lika” med uppslagsgeometrin. På Oracle, MySQL och SpatiaLite testar det rumslig likhet, medan det på PostGIS testar likhet mellan begränsningsrutor.

Exempel:

```
Zipcode.objects.filter(poly=geom)
```

| Backend | SQL-ekvivalent |
| --- | --- |
| PostGIS | `poly ~= geom` |
| Oracle | `SDO_EQUAL(poly, geom)` |
| MariaDB | `ST_Equals(poly, geom)` |
| MySQL | `ST_Equals(poly, geom)` |
| SpatiaLite | `Equals(poly, geom)` |

### `skärningspunkter`

*Tillgänglighet*: [PostGIS](https://postgis.net/docs/ST_Intersects.html), Oracle, MariaDB, MySQL, SpatiaLite, PGRaster (Bilateral)

Testar om geometrifältet rumsligt korsar uppslagsgeometrin.

Exempel:

```
Zipcode.objects.filter(poly__intersects=geom)
```

| Backend | SQL-ekvivalent |
| --- | --- |
| PostGIS | `ST_Intersects(poly, geom)` |
| Oracle | `SDO_OVERLAPBDYINTERSECT(poly, geom)` |
| MariaDB | `ST_Intersects(poly, geom)` |
| MySQL | `ST_Intersects(poly, geom)` |
| SpatiaLite | `Intersekter(poly, geom)` |

### `isempty`

*Tillgänglighet*: [PostGIS](https://postgis.net/docs/ST_IsEmpty.html)

Testar om geometrin är tom.

Exempel:

```
Zipcode.objects.filter(poly__isempty=True)
```

### `isvalid`

*Tillgänglighet*: MySQL, [PostGIS](https://postgis.net/docs/ST_IsValid.html), Oracle, SpatiaLite

Testar om geometrin är giltig.

Exempel:

```
Zipcode.objects.filter(poly__isvalid=True)
```

| Backend | SQL-ekvivalent |
| --- | --- |
| MySQL, PostGIS, SpatiaLite | `ST_IsValid(poly)` |
| Oracle | `SDO_GEOM.VALIDATE_GEOMETRY_WITH_CONTEXT(poly, 0.05) = 'TRUE'` |

### `överlappar`

*Tillgänglighet*: [PostGIS](https://postgis.net/docs/ST_Overlaps.html), Oracle, MariaDB, MySQL, SpatiaLite, PGRaster (Bilateral)

Testar om geometrifältet spatialt överlappar lookup-geometrin.

| Backend | SQL-ekvivalent |
| --- | --- |
| PostGIS | `ST_Overlaps(poly, geom)` |
| Oracle | `SDO_OVERLAPS(poly, geom)` |
| MariaDB | `ST_Overlaps(poly, geom)` |
| MySQL | `ST_Overlaps(poly, geom)` |
| SpatiaLite | `Överlappningar(poly, geom)` |

### `förhållande`

*Tillgänglighet*: [PostGIS](https://postgis.net/docs/ST_Relate.html), MariaDB, Oracle, SpatiaLite, PGRaster (Konvertering)

Testar om geometrifältet är rumsligt relaterat till uppslagsgeometrin med de värden som anges i det givna mönstret.  Denna sökning kräver en tuple-parameter, `(geom, pattern)`; formen av `pattern` beror på den spatiala backend:

#### MariaDB, PostGIS och SpatiaLite

I dessa rumsliga backends är intersektionsmönstret en sträng bestående av nio tecken som definierar intersektioner mellan geometrifältets insida, gräns och utsida och uppslagsgeometrin. Matrisen för intersektionsmönstret får endast innehålla följande tecken: `1`, `2`, `T`, `F` eller `*`.  Denna uppslagstyp gör det möjligt för användare att ”finjustera” ett specifikt geometriskt förhållande som överensstämmer med DE-9IM-modellen. \[#fnde9im\] \_ \_

Geometri exempel:

```
# A tuple lookup parameter is used to specify the geometry and
# the intersection pattern (the pattern here is for 'contains').
Zipcode.objects.filter(poly__relate=(geom, "T*T***FF*"))
```

PostGIS och MariaDB SQL motsvarande:

```sql
SELECT ... WHERE ST_Relate(poly, geom, 'T*T***FF*')
```

SpatiaLite SQL-ekvivalent:

```sql
SELECT ... WHERE Relate(poly, geom, 'T*T***FF*')
```

Rasterexempel:

```
Zipcode.objects.filter(poly__relate=(rast, 1, "T*T***FF*"))
Zipcode.objects.filter(rast__2__relate=(rast, 1, "T*T***FF*"))
```

PostGIS SQL-ekvivalent:

```sql
SELECT ... WHERE ST_Relate(poly, ST_Polygon(rast, 1), 'T*T***FF*')
SELECT ... WHERE ST_Relate(ST_Polygon(rast, 2), ST_Polygon(rast, 1), 'T*T***FF*')
```

#### Oracle

Här består relationsmönstret av minst en av de nio relationssträngarna: `TOUCH`, `OVERLAPBDYDISJOINT`, `OVERLAPBDYINTERSECT`, `EQUAL`, `INSIDE`, `COVEREDBY`, `CONTAINS`, `COVERS`, `ON` och `ANYINTERACT`.   Flera strängar kan kombineras med den logiska booleska operatorn OR, till exempel `'inside+touch'`. [^2] Relationssträngarna är okänsliga för stora och små bokstäver.

Exempel:

```
Zipcode.objects.filter(poly__relate=(geom, "anyinteract"))
```

Oracle SQL motsvarande:

```sql
SELECT ... WHERE SDO_RELATE(poly, geom, 'anyinteract')
```

### `touches`

*Tillgänglighet*: [PostGIS](https://postgis.net/docs/ST_Touches.html), Oracle, MariaDB, MySQL, SpatiaLite

Testar om geometrifältet rumsligt berör uppslagsgeometrin.

Exempel:

```
Zipcode.objects.filter(poly__touches=geom)
```

| Backend | SQL-ekvivalent |
| --- | --- |
| PostGIS | `ST_Touches(poly, geom)` |
| MariaDB | `ST_Touches(poly, geom)` |
| MySQL | `ST_Touches(poly, geom)` |
| Oracle | `SDO_TOUCH(poly, geom)` |
| SpatiaLite | `Touches(poly, geom)` |

### `inom`

*Tillgänglighet*: [PostGIS](https://postgis.net/docs/ST_Within.html), Oracle, MariaDB, MySQL, SpatiaLite, PGRaster (Bilateral)

Testar om geometrifältet är rumsligt inom lookup-geometrin.

Exempel:

```
Zipcode.objects.filter(poly__within=geom)
```

| Backend | SQL-ekvivalent |
| --- | --- |
| PostGIS | `ST_Within(poly, geom)` |
| MariaDB | `ST_Within(poly, geom)` |
| MySQL | `ST_Within(poly, geom)` |
| Oracle | `SDO_INSIDE(poly, geom)` |
| SpatiaLite | `Inom(poly, geom)` |

### `vänster`

*Tillgänglighet*: [PostGIS](https://postgis.net/docs/ST_Geometry_Left.html), PGRaster (Konvertering)

Testar om geometrifältets avgränsningsbox ligger strikt till vänster om uppslagsgeometrins avgränsningsbox.

Exempel:

```
Zipcode.objects.filter(poly__left=geom)
```

PostGIS-ekvivalent:

```sql
SELECT ... WHERE poly << geom
```

### `höger`

*Tillgänglighet*: [PostGIS](https://postgis.net/docs/ST_Geometry_Right.html), PGRaster (Konvertering)

Testar om geometrifältets avgränsningsbox ligger strikt till höger om uppslagsgeometrins avgränsningsbox.

Exempel:

```
Zipcode.objects.filter(poly__right=geom)
```

PostGIS-ekvivalent:

```sql
SELECT ... WHERE poly >> geom
```

### `överlappar_vänster`

*Tillgänglighet*: [PostGIS](https://postgis.net/docs/ST_Geometry_Overleft.html), PGRaster (Bilateral)

Testar om geometrifältets avgränsningsbox överlappar eller är till vänster om uppslagsgeometrins avgränsningsbox.

Exempel:

```
Zipcode.objects.filter(poly__overlaps_left=geom)
```

PostGIS-ekvivalent:

```sql
SELECT ... WHERE poly &< geom
```

### `överlappar_höger`

*Tillgänglighet*: [PostGIS](https://postgis.net/docs/ST_Geometry_Overright.html), PGRaster (Bilateral)

Testar om geometrifältets avgränsningsbox överlappar eller är till höger om uppslagsgeometrins avgränsningsbox.

Exempel:

```
Zipcode.objects.filter(poly__overlaps_right=geom)
```

PostGIS-ekvivalent:

```sql
SELECT ... WHERE poly &> geom
```

### `överlappningar_över`

*Tillgänglighet*: [PostGIS](https://postgis.net/docs/ST_Geometry_Overabove.html), PGRaster (Konvertering)

Testar om geometrifältets avgränsningsbox överlappar eller ligger ovanför uppslagsgeometrins avgränsningsbox.

Exempel:

```
Zipcode.objects.filter(poly__overlaps_above=geom)
```

PostGIS-ekvivalent:

```sql
SELECT ... WHERE poly |&> geom
```

### `överlappningar_under`

*Tillgänglighet*: [PostGIS](https://postgis.net/docs/ST_Geometry_Overbelow.html), PGRaster (Konvertering)

Testar om geometrifältets avgränsningsbox överlappar eller ligger under uppslagsgeometrins avgränsningsbox.

Exempel:

```
Zipcode.objects.filter(poly__overlaps_below=geom)
```

PostGIS-ekvivalent:

```sql
SELECT ... WHERE poly &<| geom
```

### ”strikt ovan

*Tillgänglighet*: [PostGIS](https://postgis.net/docs/ST_Geometry_Above.html), PGRaster (Konvertering)

Testar om geometrifältets begränsningsbox är strikt ovanför uppslagsgeometrins begränsningsbox.

Exempel:

```
Zipcode.objects.filter(poly__strictly_above=geom)
```

PostGIS-ekvivalent:

```sql
SELECT ... WHERE poly |>> geom
```

### `strikt_under`

*Tillgänglighet*: [PostGIS](https://postgis.net/docs/ST_Geometry_Below.html), PGRaster (Konvertering)

Testar om geometrifältets avgränsningsbox är strikt under uppslagsgeometrins avgränsningsbox.

Exempel:

```
Zipcode.objects.filter(poly__strictly_below=geom)
```

PostGIS-ekvivalent:

```sql
SELECT ... WHERE poly <<| geom
```

## Uppslagning av avstånd

*Tillgänglighet*: PostGIS, Oracle, MariaDB, MySQL, SpatiaLite, PGRaster (inbyggd)

För en översikt över hur du utför avståndsfrågor, se [introduktion till avståndsfrågor](/sv/5.2/ref/contrib/gis/db-api/#distance-queries).

Distansuppslagningar har följande form:

```text
<field>__<distance lookup>=(<geometry/raster>, <distance value>[, "spheroid"])
<field>__<distance lookup>=(<raster>, <band_index>, <distance value>[, "spheroid"])
<field>__<band_index>__<distance lookup>=(<raster>, <band_index>, <distance value>[, "spheroid"])
```

Värdet som skickas till en avståndsuppslagning är en tupel; de två första värdena är obligatoriska och är geometrin att beräkna avstånd till och ett avståndsvärde (antingen ett tal i fältets enheter, ett [`Distance`](/sv/5.2/ref/contrib/gis/measure/#django.contrib.gis.measure.Distance)-objekt eller ett [query expression](/sv/5.2/ref/models/expressions/)). Om du vill skicka ett bandindex till uppslagningen använder du en 3-tupel där den andra posten är bandindexet.

För varje avståndsuppslagning utom [`dwithin`](#std-fieldlookup-dwithin) kan ett valfritt element, `'spheroid'`, inkluderas för att använda de mer exakta funktionerna för beräkning av sfäroidavstånd på fält med ett geodetiskt koordinatsystem.

På PostgreSQL använder alternativet `'spheroid'` [ST\_DistanceSpheroid](https://postgis.net/docs/ST_Distance_Spheroid.html) istället för [ST\_DistanceSphere](https://postgis.net/docs/ST_DistanceSphere.html). Den enklare funktionen [ST\_Distance](https://postgis.net/docs/ST_Distance.html) används med projicerade koordinatsystem. Rasters konverteras till geometrier för sfäroidbaserade uppslagningar.

### `avstånd_gt`

Returnerar modeller där avståndet till geometrifältet från uppslagsgeometrin är större än det angivna avståndsvärdet.

Exempel:

```
Zipcode.objects.filter(poly__distance_gt=(geom, D(m=5)))
```

| Backend | SQL-ekvivalent |
| --- | --- |
| PostGIS | `ST_Distance/ST_Distance_Sphere(poly, geom) > 5` |
| MariaDB | `ST_Distance(poly, geom) > 5` |
| MySQL | `ST_Distance(poly, geom) > 5` |
| Oracle | `SDO_GEOM.SDO_DISTANCE(poly, geom, 0.05) > 5` |
| SpatiaLite | `Distans(poly, geom) > 5` |

### `avstånd_gte`

Returnerar modeller där avståndet till geometrifältet från uppslagsgeometrin är större än eller lika med det angivna avståndsvärdet.

Exempel:

```
Zipcode.objects.filter(poly__distance_gte=(geom, D(m=5)))
```

| Backend | SQL-ekvivalent |
| --- | --- |
| PostGIS | `ST_Distance/ST_Distance_Sphere(poly, geom) >= 5` |
| MariaDB | `ST_Distance(poly, geom) >= 5` |
| MySQL | `ST_Distance(poly, geom) >= 5` |
| Oracle | `SDO_GEOM.SDO_DISTANCE(poly, geom, 0.05) >= 5` |
| SpatiaLite | `Distans(poly, geom) >= 5` |

### `avstånd_lt`

Returnerar modeller där avståndet till geometrifältet från uppslagsgeometrin är mindre än det angivna avståndsvärdet.

Exempel:

```
Zipcode.objects.filter(poly__distance_lt=(geom, D(m=5)))
```

| Backend | SQL-ekvivalent |
| --- | --- |
| PostGIS | `ST_Distance/ST_Distance_Sphere(poly, geom) < 5` |
| MariaDB | `ST_Distance(poly, geom) < 5` |
| MySQL | `ST_Distance(poly, geom) < 5` |
| Oracle | `SDO_GEOM.SDO_DISTANCE(poly, geom, 0.05) < 5` |
| SpatiaLite | `Distans(poly, geom) < 5` |

### `avstånd_lte`

Returnerar modeller där avståndet till geometrifältet från uppslagsgeometrin är mindre än eller lika med det angivna avståndsvärdet.

Exempel:

```
Zipcode.objects.filter(poly__distance_lte=(geom, D(m=5)))
```

| Backend | SQL-ekvivalent |
| --- | --- |
| PostGIS | `ST_Distance/ST_Distance_Sphere(poly, geom) <= 5` |
| MariaDB | `ST_Distance(poly, geom) <= 5` |
| MySQL | `ST_Distance(poly, geom) <= 5` |
| Oracle | `SDO_GEOM.SDO_DISTANCE(poly, geom, 0.05) <= 5` |
| SpatiaLite | `Distans(poly, geom) <= 5` |

### `inom`

Returnerar modeller där avståndet till geometrifältet från uppslagsgeometrin ligger inom det angivna avståndet från varandra. Observera att du endast kan tillhandahålla [`Distance`](/sv/5.2/ref/contrib/gis/measure/#django.contrib.gis.measure.Distance)-objekt om de riktade geometrierna är i ett projicerat system. För geografiska geometrier bör du använda enheter i geometrifältet (t.ex. grader för `WGS84`) .

Exempel:

```
Zipcode.objects.filter(poly__dwithin=(geom, D(m=5)))
```

| Backend | SQL-ekvivalent |
| --- | --- |
| PostGIS | `ST_DWithin(poly, geom, 5)` |
| Oracle | `SDO_WITHIN_DISTANCE(poly, geom, 5)` |
| SpatiaLite | `PtDistWithin(poly, geom, 5)` |

### Aggregerade funktioner

Django tillhandahåller några GIS-specifika aggregeringsfunktioner. För detaljer om hur du använder dessa aggregeringsfunktioner, se [ämnesguiden om aggregering](/sv/5.2/topics/db/aggregation/).

| Sökord Argument | Beskrivning |
| --- | --- |
| ”Tolerans | Detta nyckelord är endast för Oracle.  Det är för det toleransvärde som används av proceduren `SDOAGGRTYPE`; [Oracle-dokumentationen](https://docs.oracle.com/en/database/oracle/oracle-database/21/spatl/spatial-concepts.html#GUID-CE10AB14-D5EA-43BA-A647-DAC9EEF41EE6) innehåller mer information. |

Exempel:

```pycon
>>> from django.contrib.gis.db.models import Extent, Union
>>> WorldBorder.objects.aggregate(Extent("mpoly"), Union("mpoly"))
```

#### `Samla in`

#### `class Collect(geo_field, filter=None)`

*Tillgänglighet*: [PostGIS](https://postgis.net/docs/ST_Collect.html), MySQL, SpatiaLite

Returnerar en `GEOMETRYCOLLECTION` eller ett `MULTI` geometriobjekt från geometrikolumnen. Detta är analogt med en förenklad version av aggregatet [`Union`](#django.contrib.gis.db.models.Union), förutom att det kan vara flera storleksordningar snabbare än att utföra en union eftersom det rullar upp geometrier till en samling eller ett multiobjekt, utan att bry sig om att lösa upp gränser.

> **Changed in Django 5.1**
>
> Stöd för MySQL 8.0.24+ har lagts till.

#### `Extent`

#### `class Extent(geo_field, filter=None)`

*Tillgänglighet*: [PostGIS](https://postgis.net/docs/ST_Extent.html), Oracle, SpatiaLite

Returnerar omfattningen av alla `geo_field` i `QuerySet` som en 4-tupel, bestående av den nedre vänstra koordinaten och den övre högra koordinaten.

Exempel:

```pycon
>>> qs = City.objects.filter(name__in=("Houston", "Dallas")).aggregate(Extent("poly"))
>>> print(qs["poly__extent"])
(-96.8016128540039, 29.7633724212646, -95.3631439208984, 32.782058715820)
```

#### `Extent3D`

#### `class Extent3D(geo_field, filter=None)`

*Tillgänglighet*: [PostGIS](https://postgis.net/docs/ST_3DExtent.html)

Returnerar 3D-utbredningen av alla `geo_field` i `QuerySet` som en 6-tupel, bestående av den nedre vänstra koordinaten och den övre högra koordinaten (var och en med x-, y- och z-koordinater).

Exempel:

```pycon
>>> qs = City.objects.filter(name__in=("Houston", "Dallas")).aggregate(Extent3D("poly"))
>>> print(qs["poly__extent3d"])
(-96.8016128540039, 29.7633724212646, 0, -95.3631439208984, 32.782058715820, 0)
```

#### `MakeLine`

#### `class MakeLine(geo_field, filter=None)`

*Tillgänglighet*: [PostGIS](https://postgis.net/docs/ST_MakeLine.html), SpatiaLite

Returnerar en `LineString` som konstruerats från punktfältsgeometrierna i `QuerySet`. För närvarande har det ingen effekt att beställa frågeuppsättningen.

Exempel:

```pycon
>>> qs = City.objects.filter(name__in=("Houston", "Dallas")).aggregate(MakeLine("poly"))
>>> print(qs["poly__makeline"])
LINESTRING (-95.3631510000000020 29.7633739999999989, -96.8016109999999941 32.7820570000000018)
```

#### `Union`

#### `class Union(geo_field, filter=None)`

*Tillgänglighet*: [PostGIS](https://postgis.net/docs/ST_Union.html), Oracle, SpatiaLite

Denna metod returnerar ett [`GEOSGeometry`](/sv/5.2/ref/contrib/gis/geos/#django.contrib.gis.geos.GEOSGeometry)-objekt som består av en sammanslagning av alla geometrier i frågeuppsättningen. Observera att användningen av `Union` är processorkrävande och kan ta lång tid på stora frågeuppsättningar.

> **Note**
>
> Om beräkningstiden för att använda denna metod är för dyr kan du överväga att använda [`Collect`](#django.contrib.gis.db.models.Collect) istället.

Exempel:

```pycon
>>> u = Zipcode.objects.aggregate(Union(poly))  # This may take a long time.
>>> u = Zipcode.objects.filter(poly__within=bbox).aggregate(
...     Union(poly)
... )  # A more sensible approach.
```

**Fotnoter**

[^1]: *Se* [OpenGIS Simple Feature Specification For SQL](https://portal.ogc.org/files/?artifact_id=829), på kap. 2.1.13.2, s. 2-13 (Den dimensionellt utökade modellen med nio intersektioner).

[^2]: *Se* [SDO\_RELATE-dokumentation](https://docs.oracle.com/en/database/oracle/oracle-database/18/spatl/spatial-operators-reference.html#GUID-97C17C18-F05E-49B4-BE11-E89B972E2A02), från Oracle Spatial and Graph Developer’s Guide.

[^3]: För en förklaring av denna rutin, läs [Quirks of the ”Contains” Spatial Predicate](https://lin-ear-th-inking.blogspot.com/2007/06/subtleties-of-ogc-covers-spatial.html) av Martin Davis (en PostGIS-utvecklare).