---
title: "LayerMapping verktyg för dataimport"
version: 5.2
locale: sv
source: https://docs.djangoproject.com/sv/5.2/ref/contrib/gis/layermapping/
canonical: https://djangodocs.dev/sv/5.2/ref/contrib/gis/layermapping/
---
# `LayerMapping` verktyg för dataimport

Klassen [`LayerMapping`](#django.contrib.gis.utils.LayerMapping) ger ett sätt att mappa innehållet i vektorbaserade rumsliga datafiler (t.ex. shapefiler) till GeoDjango-modeller.

Detta verktyg växte fram ur författarens personliga behov av att eliminera kodupprepningen som gick ut på att dra ut geometrier och fält från ett vektorlager, konvertera till ett annat koordinatsystem (t.ex. WGS84) och sedan infoga i en GeoDjango-modell.

> **Note**
>
> Användning av [`LayerMapping`](#django.contrib.gis.utils.LayerMapping) kräver GDAL.

> **Warning**
>
> GIS-datakällor, t.ex. shapefiler, kan vara mycket stora.  Om du upptäcker att [`LayerMapping`](#django.contrib.gis.utils.LayerMapping) använder för mycket minne, sätt [`DEBUG`](/sv/5.2/ref/settings/#std-setting-DEBUG) till `False` i dina inställningar.  När [`DEBUG`](/sv/5.2/ref/settings/#std-setting-DEBUG) är satt till `True` loggar Django [automatiskt](/sv/5.2/faq/models/#faq-see-raw-sql-queries) *varje* SQL-fråga – och när SQL-satser innehåller geometrier kan detta förbruka mer minne än vad som är normalt.

## Exempel

1. Du behöver en GDAL-stödd datakälla, t.ex. en shapefil (här använder vi en enkel polygon-shapefil, `test_poly.shp`, med tre funktioner):

```pycon
>>> from django.contrib.gis.gdal import DataSource
>>> ds = DataSource("test_poly.shp")
>>> layer = ds[0]
>>> print(layer.fields)  # Exploring the fields in the layer, we only want the 'str' field.
['float', 'int', 'str']
>>> print(len(layer))  # getting the number of features in the layer (should be 3)
3
>>> print(layer.geom_type)  # Should be 'Polygon'
Polygon
>>> print(layer.srs)  # WGS84 in WKT
GEOGCS["GCS_WGS_1984",
    DATUM["WGS_1984",
        SPHEROID["WGS_1984",6378137,298.257223563]],
    PRIMEM["Greenwich",0],
    UNIT["Degree",0.017453292519943295]]
```

1. Nu definierar vi vår motsvarande Django-modell (se till att använda [`migrate`](/sv/5.2/ref/django-admin/#django-admin-migrate)):

   ```
   from django.contrib.gis.db import models

   class TestGeo(models.Model):
       name = models.CharField(max_length=25)  # corresponds to the 'str' field
       poly = models.PolygonField(srid=4269)  # we want our model in a different SRID

       def __str__(self):
           return "Name: %s" % self.name
   ```
2. Använd [`LayerMapping`](#django.contrib.gis.utils.LayerMapping) för att extrahera alla funktioner och placera dem i databasen:

```pycon
>>> from django.contrib.gis.utils import LayerMapping
>>> from geoapp.models import TestGeo
>>> mapping = {
...     "name": "str",  # The 'name' model field maps to the 'str' layer field.
...     "poly": "POLYGON",  # For geometry fields use OGC name.
... }  # The mapping is a dictionary
>>> lm = LayerMapping(TestGeo, "test_poly.shp", mapping)
>>> lm.save(verbose=True)  # Save the layermap, imports the data.
Saved: Name: 1
Saved: Name: 2
Saved: Name: 3
```

Här har [`LayerMapping`](#django.contrib.gis.utils.LayerMapping) omvandlat de tre geometrierna från shapefilen i deras ursprungliga rumsliga referenssystem (WGS84) till GeoDjango-modellens rumsliga referenssystem (NAD83).  Om inget rumsligt referenssystem har definierats för skiktet, använd nyckelordet `source_srs` med ett [`SpatialReference`](/sv/5.2/ref/contrib/gis/gdal/#django.contrib.gis.gdal.SpatialReference)-objekt för att ange ett.

## aPI `LayerMapping` API

#### `class LayerMapping(model, data_source, mapping, layer=0, source_srs=None, encoding=None, transaction_mode='commit_on_success', transform=True, unique=True, using='default')`

Följande är de argument och nyckelord som kan användas vid instansiering av `LayerMapping` objekt.

| Argument | Beskrivning |
| --- | --- |
| `modell` | Den geografiska modellen, *inte* en instans. |
| `datakälla` | Sökvägen till den OGR-stödda datakällfilen (t.ex. en shapefil).  Accepterar även [`django.contrib.gis.gdal.DataSource`](/sv/5.2/ref/contrib/gis/gdal/#django.contrib.gis.gdal.DataSource)-instanser. |
| `mappning` | En ordbok: nycklarna är strängar som motsvarar modellfältet och värdena motsvarar strängfältsnamn för OGR-objektet, eller om modellfältet är geografiskt bör det motsvara OGR:s geometrityp, t.ex. `'POINT'`, `'LINESTRING'`, `'POLYGON'`. |

| Argument för nyckelord |  |
| --- | --- |
| `lager` | Indexet för det lager som ska användas från datakällan (standardvärde 0) |
| `källa_srs` | Använd detta för att ange källan SRS manuellt (till exempel, vissa shapefiler levereras inte med en `'.prj`-fil).  Ett heltal SRID, WKT- eller PROJ-strängar och [`django.contrib.gis.gdal.SpatialReference`](/sv/5.2/ref/contrib/gis/gdal/#django.contrib.gis.gdal.SpatialReference)-objekt accepteras. |
| `kodning` | Anger teckenuppsättningskodningen för strängarna i OGR-datakällan.  Exempelvis är `'latin-1'`, `'utf-8'` och `'cp437'` alla giltiga kodningsparametrar. |
| `transaktionsläge` | Kan vara `'commit_on_success` (standard) eller `'autocommit`. |
| `transform` | Om du ställer in detta på False inaktiveras koordinattransformationer.  Med andra ord kommer geometrier att infogas i databasen oförändrade från sitt ursprungliga tillstånd i datakällan. |
| `unique` | Om du ställer in detta till namnet, eller en tupel av namn, från den givna modellen skapas modeller som är unika endast för det eller de angivna namnen. Geometrier från varje funktion kommer att läggas till i den samling som är associerad med den unika modellen.  Tvingar transaktionsläget att vara `'autocommit'`. |
| `använder` | Anger den databas som ska användas vid import av rumsliga data. Standard är `'default'`. |

### `save()` Nyckelord Argument

#### `LayerMapping.save(verbose=False, fid_range=False, step=False, progress=False, silent=False, stream=sys.stdout, strict=False)`

Metoden `save()` accepterar även nyckelord.  Dessa nyckelord används för att styra loggning av utdata, felhantering och för att importera specifika funktionsområden.

| Spara sökordsargument | Beskrivning |
| --- | --- |
| `fid_range` | Kan anges med en del eller en tupel av (början, slut) funktions-ID:n som ska mappas från datakällan.  Med andra ord gör detta nyckelord det möjligt för användaren att selektivt importera en delmängd av funktioner i den geografiska datakällan. |
| `framsteg` | När detta nyckelord är inställt skrivs statusinformation ut som anger antalet funktioner som har bearbetats och sparats.  Som standard skrivs statusinformationen ut var 1000:e bearbetad funktion, men denna standard kan åsidosättas genom att ange detta nyckelord med ett heltal för önskat intervall. |
| `silent` | Som standard skrivs icke-fatala felmeddelanden ut till `sys.stdout`, men detta nyckelord kan anges för att inaktivera dessa meddelanden. |
| `steg` | Om det anges med ett heltal kommer transaktioner att ske vid varje stegintervall. Om t.ex. `step=1000`, kommer en transaktion att ske efter den 1 000:e funktionen, den 2 000:e funktionen osv. |
| `ström` | Statusinformation kommer att skrivas till detta filhandtag.  Standard är att använda `sys.stdout`, men alla objekt med en `write`-metod stöds. |
| `strikt` | Exekveringen av modellmappningen kommer att avbrytas vid det första felet som påträffas.  Standardvärdet (`False`) är att försöka fortsätta. |
| `verbose` | Om den är inställd kommer information att skrivas ut efter varje modellsparning som utförs i databasen. |

## Felsökning

### Minnet tar slut

Som nämnts i varningen högst upp i detta avsnitt lagrar Django alla SQL-frågor när `DEBUG=True`.  Ställ in `DEBUG=False` i dina inställningar, och detta bör stoppa överdriven minnesanvändning när du kör `LayerMapping` skript.

### MySQL: `max_allowed_packet` fel

Om du stöter på följande fel när du använder `LayerMapping` och MySQL:

```pytb
OperationalError: (1153, "Got a packet bigger than 'max_allowed_packet' bytes")
```

Då är lösningen att öka värdet på inställningen `max_allowed_packet` i din MySQL-konfiguration.  Standardvärdet kan till exempel vara något så lågt som en megabyte – inställningen kan ändras i MySQL:s konfigurationsfil (`my.cnf`) i avsnittet `[mysqld]`:

```ini
max_allowed_packet = 10M
```