{"canonical_url":"https://engineer.company/sv/glossary/orm/","content_markdown":"# ORM\n\n## Vad det är\n\nEn ORM, kort för object-relational mapper, är ett bibliotek som kopplar\ntabellerna i en relationsdatabas till klasser i applikationskoden, och raderna i\ndem till objekt. Koden ber om en författare och får tillbaka ett\n`Author`-objekt, ändrar ett av dess attribut och sparar det, och ORM-biblioteket\nskriver de `SELECT`-, `INSERT`- och `UPDATE`-satser som gör jobbet. Modellerna i\nDjango och ORM-delen av SQLAlchemy, båda skrivna i Python, är två välkända\nexempel, och det är dem den här artikeln bygger på.\n\nMappningen behövs eftersom de två sidorna organiserar data på olika sätt. Martin\nFowler säger det rakt ut i sin beskrivning av mönstret Data Mapper: objekt och\nrelationsdatabaser strukturerar data på var sitt sätt, och delar av en\nobjektmodell, som samlingar och arv, har ingen motsvarighet i en\nrelationsdatabas. Att flytta data mellan de två blir ett problem i sig, och en\nORM är ett färdigt svar på det.\n\nDelarna i det svaret fick namn i Fowlers bok Patterns of Enterprise Application\nArchitecture från 2003, och bokens mönsterkatalog finns fritt tillgänglig på\nnätet. Två mönster beskriver den övergripande formen. Active Record är ett\nobjekt som kapslar in en rad i en tabell, själv sköter åtkomsten till databasen\noch bär domänlogiken för de data det håller; enligt designfilosofin i Django\nföljer modellerna där just det mönstret. Data Mapper är ett separat lager som\nflyttar data mellan objekten och databasen och håller dem oberoende av varandra,\nså att objekten inte behöver veta att det finns en databas alls. Runt dem finns\nflera mindre mönster. Identity Map ser till att varje objekt bara läses in en\ngång. Unit of Work håller en lista över de objekt som ett arbetsmoment har\nändrat och skriver ut ändringarna tillsammans. Lazy Load är ett objekt som bara\ninnehåller en del av de data koden behöver men vet hur resten hämtas.\nDokumentationen till SQLAlchemy nämner två av dem direkt: `Session` håller\ninlästa objekt i en identity map, med bara ett objekt per primärnyckel, och\nsättet den samlar ändringar på och skickar ut dem till databasen med en flush är\nunit of work-mönstret.\n\n## Varför det spelar roll\n\nDet första skälet är hur mycket kod en ORM sparar. I essän ORM Hate från 2012\nkallar Fowler problemet med objektrelationell mappning svårt: det handlar om att\nhålla två mycket olika representationer av samma data i takt, och en ändring på\nden ena sidan måste föras över till den andra. Han uppskattar att en ORM\nhanterar ungefär 80 till 90 % av mappningsproblemen och menar att ett ramverk\nsom besparar ett team 80 % av det arbetet är värt att ha, även om det stannar\ndär. Varje tabell som teamet slipper mappa för hand är ett ställe mindre där en\nkolumn kan läsas in i fel attribut.\n\nDet andra skälet är konsekvens inuti ett körande program. Med en identity map\nreturnerar två frågor som hittar samma rad samma objekt, så att en ändring som\ngörs via den ena referensen syns via den andra; dokumentationen till SQLAlchemy\nvisar det genom att hämta samma primärnyckel två gånger och få exakt samma\nobjekt tillbaka. Med en unit of work samlar ORM-biblioteket väntande\ninfogningar, uppdateringar och borttagningar och skriver enligt funktionslistan\nför SQLAlchemy ut dem i en enda omgång, så att applikationskoden inte själv\nbehöver hålla reda på vilka objekt den har rört. Django gör medvetet det\nmotsatta valet: designfilosofin kräver ett uttryckligt anrop till `save()` i\nstället för att ramverket sparar i det tysta, så att det skickas så få\nSQL-satser som möjligt.\n\nDet tredje skälet är var gränsen går. Fowler beskriver en bra ORM som en som tar\nhand om rutinarbetet men ger ett manhål ner till SQL-koden när det behövs, och\nhan säger rakt ut att den som bygger på en relationsdatabas måste veta hur en\nsådan databas fungerar. Designfilosofin i Django säger samma sak från ramverkets\nsida: databas-API:t ska veta att det är en genväg och inte nödvändigtvis hela\nsvaret, och ramverket ska göra det enkelt att skriva egen SQL, vare sig det är\nhela satser eller bara ett eget `WHERE`-villkor. En ORM förtjänar sin plats i\nden rutinmässiga delen av dataåtkomsten; resten är där ett team använder sina\nSQL-kunskaper.\n\n## Så ser det ut i praktiken\n\nDen kostnad som en ORM oftast döljer är antalet frågor den skickar. I SQLAlchemy\n2.1 laddas relationer lat som standard: de relaterade objekten hämtas första\ngången koden rör attributet. Dokumentationen säger det rakt ut: för N inlästa\nobjekt ger åtkomst till deras latladdade attribut N+1 `SELECT`-satser. Exemplet\nnedan förutsätter att klasserna `Author` och `Book` redan är mappade med en\nen-till-många-relation, `Author.books`, och går igenom författarna på tre sätt.\n\n```python\nfrom sqlalchemy import select\nfrom sqlalchemy.orm import raiseload, selectinload\n\n# Standard: en SELECT för författarna och sedan en till för varje\n# författare vars böcker loopen rör, N+1 satser sammanlagt.\nauthors = session.scalars(select(Author)).all()\nfor author in authors:\n    print(author.name, len(author.books))\n\n# select IN-laddning: en andra SELECT hämtar böckerna för alla\n# författare på en gång, med deras primärnycklar i ett IN-villkor.\nstmt = select(Author).options(selectinload(Author.books))\nfor author in session.scalars(stmt).all():\n    print(author.name, len(author.books))\n\n# raise-laddning: åtkomst till author.books ger nu ett fel\n# i stället för att i det tysta skicka ännu en fråga.\nstmt = select(Author).options(raiseload(Author.books))\n```\n\nFör en-till-många- och många-till-många-samlingar kallar dokumentationen\n`selectinload()` i allmänhet den bästa strategin. `joinedload()`, som den kallar\nden mest allsidiga strategin, lägger till en `JOIN` i den ursprungliga satsen,\nsom standard en `LEFT OUTER JOIN`, så att de relaterade raderna kommer i samma\nresultatmängd. `raiseload()` finns för att skydda mot oönskade laddningar, och\njokerteckenformen `raiseload(\"*\")` utvidgar skyddet till de andra relationerna\nockså, inklusive dem på de objekt som satsen faktiskt hämtar.\n\nDjango 6.1 ger samma val ett eget namn: fetch modes. När koden rör ett fält som\nden ursprungliga frågan inte hämtade, till exempel en främmande nyckel, en\nen-till-en-relation eller ett fält som utelämnats med `defer()` eller `only()`,\nhämtar standardläget `FETCH_ONE` det för just den instansen, och dokumentationen\nkallar själv resultatet för N+1-problemet. `FETCH_PEERS`, som är nytt i 6.1,\nhämtar det saknade fältet för instansen och för alla andra instanser från samma\n`QuerySet`, utifrån antagandet att kod som behöver ett fält för en rad i regel\nbehöver det för alla. `FETCH_RAISE` utlöser i stället `FieldFetchBlocked`. Ett\nläge sätts per `QuerySet`, som i `Book.objects.fetch_mode(models.FETCH_PEERS)`,\neller som standard för en modell via en egen manager, och Django kopierar det\nvidare till de relaterade objekt som hämtas. Där `FETCH_PEERS` inte passar eller\ninte är tillräckligt effektivt hänvisar optimeringsguiden till\n`select_related()` och `prefetch_related()`.\n\nFöretagets egna sidor drar gränsen längre in mot databasen än de flesta.\n[Sidan om teknikstacken](/sv/tech-stack/) behandlar SQL som ett fullvärdigt\nspråk snarare än något en ORM genererar, eftersom det mesta av det\nprestandaarbete som företaget kallas in för finns där. I arbetet hos NextMariner\ndrev grundaren tanken hela vägen med\n[ett funktionsbaserat skikt i PostgreSQL](/sv/portfolio/designed-a-function-first-postgresql-data-layer/):\nvarje operation som appen kan utföra är en av 1 275 lagrade funktioner i 34\nscheman, och det finns ingen direkt tabellåtkomst från Go över huvud taget.\nRollen som API-lagret loggar in som har `EXECUTE` på de funktionerna och `USAGE`\npå deras scheman och inget annat, så den kan inte röra en tabell direkt. Sidan\ndöljer inte priset: ett nytt fält kräver en ändring i en tabell och dessutom i\nen funktion, inte bara en ny rad i en fråga.\n\n## Var det går fel\n\n**En loop skickar en fråga per rad.** N+1-mönstret ovan ser ofarligt ut i en\nliten utvecklingsdatabas och gör en sida långsammare i takt med antalet rader.\nBestäm laddningen för varje väg genom koden som spelar roll, med\n`selectinload()` eller `joinedload()` i SQLAlchemy och `FETCH_PEERS`,\n`select_related()` eller `prefetch_related()` i Django. Se sedan till att det\noplanerade fallet misslyckas högljutt: `raiseload()` i SQLAlchemy, eller\n`FETCH_RAISE`, som dokumentationen till Django beskriver som ett sätt att\nförhindra oavsiktliga frågor i prestandakritisk kod.\n\n**Ingen läser den SQL som ORM-biblioteket skriver.** En ORM skriver SQL som\ningen i teamet har valt, och den koden förblir osynlig tills en sida blir\nlångsam. Optimeringsguiden till Django börjar just här: ta reda på vilka frågor\nen sida kör och vad de kostar, använd `QuerySet.explain()` för att se hur\ndatabasen kör ett visst `QuerySet`, och läs `django.db.connection.queries` för\natt se vad Django skriver för kodens räkning. Gör läsningen av den SQL-koden\ntill en fast del av granskningen av varje viktig sida eller körning, och kör de\nlångsamma satserna genom databasens egen frågeplan.\n\n**Arbete som hör hemma i databasen körs i Python.** Att hämta rader bara för att\nfiltrera dem, jämföra två av deras fält eller summera dem flyttar varenda rad\növer anslutningen för att i applikationskoden göra det som databasen kunde ha\ngjort där datan redan ligger. Guiden till Django räknar upp alternativen:\n`filter()` och `exclude()` för att filtrera i databasen, `F()`-uttryck för att\njämföra fält i samma modell och `annotate()` för att aggregera i databasen.\nSkrivningar följer samma regel, med `bulk_create()` och `bulk_update()` i\nstället för en `save()` per objekt, efter att man har kontrollerat de förbehåll\nsom dokumentationen anger för båda. Vid en mycket stor resultatmängd håller ett\n`QuerySet` kvar allt det har läst och kan använda mycket minne, och då kan\n`iterator()` hjälpa.\n\n**Den sista delen tvingas genom ORM-biblioteket.** Fowlers egen uppskattning\nlämnar kvar 10 till 20 % av mappningsproblemen, och den sista delen kräver\nenligt honom alltid noggrant arbete. Att böja en ORM tills den producerar en\nviss sats gömmer det arbetet i genererad SQL som ingen har valt. Skriv de\nsatserna i SQL och granska dem som all annan kod. Guiden till Django nämner\nstegen nedåt: uttrycket `RawSQL` lägger till uttrycklig SQL i en fråga, mindre\nportabelt men kraftfullare, och bortom det kan ett team skriva sin egen SQL för\natt hämta data eller fylla modeller. Håll ORM-biblioteket till de rutinmässiga\nposterna, där det sparar mest och kostar minst.\n\n## Läs mer\n\n- [Catalog of Patterns of Enterprise Application Architecture](https://martinfowler.com/eaaCatalog/)\n  — Martin Fowlers korta beskrivningar av Active Record, Data Mapper, Unit of\n  Work, Identity Map och Lazy Load.\n- [ORM Hate](https://martinfowler.com/bliki/OrmHate.html)\n  — varför objektrelationell mappning är svår, och hur mycket av den ett ramverk\n  kan ta hand om.\n- [Relationship Loading Techniques](https://docs.sqlalchemy.org/en/21/orm/queryguide/relationships.html)\n  — lat laddning, select IN, joined och raise i SQLAlchemy 2.1, och vilken\n  strategi man bör välja.\n- [Fetch modes](https://docs.djangoproject.com/en/stable/topics/db/fetch-modes/)\n  — `FETCH_ONE`, `FETCH_PEERS` och `FETCH_RAISE`, som är nya i Django 6.1.\n- [Database access optimization](https://docs.djangoproject.com/en/stable/topics/db/optimization/)\n  — profilering, utvärdering av `QuerySet`, arbete i databasen, bulkmetoder och\n  rå SQL.\n\n\u003chttps://engineer.company/sv/glossary/orm/\u003e\n","date_modified":"2026-11-09T21:50:25Z","description":"Vad en ORM gör mellan objekt och tabeller, vilka av Fowlers mönster den bygger på, vad relaterade rader kostar att hämta och fyra vanliga fallgropar.","formats":{"gemtext":"https://engineer.company/sv/glossary/orm/index.gmi","gopher":"https://engineer.company/sv/glossary/orm/gophermap","html":"https://engineer.company/sv/glossary/orm/","json":"https://engineer.company/sv/glossary/orm/index.json","markdown":"https://engineer.company/sv/glossary/orm/index.md","pdf":"https://engineer.company/sv/glossary/orm/index.pdf"},"kind":"page","language":"sv","title":"Vad är en ORM?","url":"https://engineer.company/sv/glossary/orm/","version":1}