{"canonical_url":"https://engineer.company/nb/glossary/orm/","content_markdown":"# ORM\n\n## Hva det er\n\nEn ORM, kort for object-relational mapper, er et bibliotek som kobler tabellene\ni en relasjonsdatabase til klasser i applikasjonskoden, og radene i dem til\nobjekter. Koden ber om en forfatter og får et `Author`-objekt tilbake, endrer et\nav attributtene og lagrer det, og ORM-biblioteket skriver `SELECT`-, `INSERT`-\nog `UPDATE`-setningene som gjør jobben. Modellene i Django og ORM-en i\nSQLAlchemy, begge skrevet i Python, er to kjente eksempler, og det er dem denne\nartikkelen bygger på.\n\nKartleggingen trengs fordi de to sidene organiserer data ulikt. Martin Fowler\nsier det rett ut i beskrivelsen av mønsteret Data Mapper: objekter og\nrelasjonsdatabaser strukturerer data på hver sin måte, og deler av en\nobjektmodell, som samlinger og arv, har ikke noe motstykke i en\nrelasjonsdatabase. Å flytte data mellom de to blir et problem i seg selv, og en\nORM er et ferdig svar på det.\n\nDelene av det svaret fikk navn i Fowlers bok Patterns of Enterprise Application\nArchitecture fra 2003, og mønsterkatalogen fra boken ligger fritt tilgjengelig\npå nettet. To mønstre beskriver den overordnede formen. Active Record er et\nobjekt som pakker inn én rad i en tabell, selv står for tilgangen til databasen\nog bærer domenelogikken for de dataene; ifølge designfilosofien til Django\nfølger modellene der nettopp det mønsteret. Data Mapper er et eget lag som\nflytter data mellom objektene og databasen og holder dem uavhengige av\nhverandre, slik at objektene ikke trenger å vite at det finnes en database i det\nhele tatt. Rundt dem ligger flere mindre mønstre. Identity Map sørger for at\nhvert objekt bare lastes inn én gang. Unit of Work holder en liste over\nobjektene et stykke arbeid har endret, og skriver endringene ut samlet. Lazy\nLoad er et objekt som bare inneholder en del av dataene koden trenger, men vet\nhvordan resten hentes. Dokumentasjonen til SQLAlchemy nevner to av dem direkte:\n`Session` holder innlastede objekter i et identity map, med bare ett objekt per\nprimærnøkkel, og måten den samler endringer og flusher dem til databasen på, er\nunit of work-mønsteret.\n\n## Hvorfor det er viktig\n\nDen første grunnen er hvor mye kode en ORM sparer. I essayet ORM Hate fra 2012\nkaller Fowler problemet med objektrelasjonell mapping vanskelig: det går ut på å\nholde to svært ulike representasjoner av de samme dataene i takt, og en endring\npå den ene siden må føres over til den andre. Han anslår at en ORM håndterer\nomtrent 80 til 90 % av mappingproblemene, og mener at et rammeverk som sparer et\nteam for 80 % av det arbeidet, er verdt å ha, selv om det stopper der. Hver\ntabell teamet slipper å mappe for hånd, er ett sted mindre der en kolonne kan\nbli lest inn i feil attributt.\n\nDen andre grunnen er konsistens inne i et kjørende program. Med et identity map\nreturnerer to spørringer som finner den samme raden, det samme objektet, slik at\nen endring gjort gjennom den ene referansen er synlig gjennom den andre;\ndokumentasjonen til SQLAlchemy viser det ved å hente den samme primærnøkkelen to\nganger og få nøyaktig det samme objektet tilbake. Med en unit of work samler\nORM-en ventende innsettinger, oppdateringer og slettinger og skriver dem ifølge\nfunksjonslisten til SQLAlchemy ut i én samlet omgang, slik at applikasjonskoden\nikke selv må huske hvilke objekter den har rørt. Django gjør bevisst det\nmotsatte valget: designfilosofien krever et eksplisitt kall til `save()` i\nstedet for at rammeverket lagrer i det stille, slik at det sendes så få\nSQL-setninger som mulig.\n\nDen tredje grunnen er hvor grensen går. Fowler beskriver en god ORM som en som\ntar seg av det kjedelige arbeidet, men gir et mannhull ned til SQL-en når det\ntrengs, og han sier rett ut at den som bygger på en relasjonsdatabase, må vite\nhvordan en slik database fungerer. Designfilosofien til Django sier det samme\nfra rammeverkets side: database-API-et skal vite at det er en snarvei og ikke\nnødvendigvis hele svaret, og rammeverket skal gjøre det enkelt å skrive egen\nSQL, enten det er hele setninger eller bare en egen `WHERE`-betingelse. En ORM\ngjør seg fortjent til plassen sin på den rutinepregede delen av datatilgangen;\nresten er der et team bruker SQL-kunnskapen sin.\n\n## Slik ser det ut i praksis\n\nKostnaden en ORM oftest skjuler, er antallet spørringer den sender. I SQLAlchemy\n2.1 lastes relasjoner lat som standard: de relaterte objektene hentes første\ngang koden rører attributtet. Dokumentasjonen sier det rett ut: for N innlastede\nobjekter gir tilgang til de latlastede attributtene deres N+1\n`SELECT`-setninger. Eksemplet nedenfor forutsetter at klassene `Author` og\n`Book` allerede er mappet med en en-til-mange-relasjon, `Author.books`, og går\ngjennom forfatterne på tre måter.\n\n```python\nfrom sqlalchemy import select\nfrom sqlalchemy.orm import raiseload, selectinload\n\n# Standard: én SELECT for forfatterne og så én til for hver\n# forfatter hvis bøker løkken rører, N+1 setninger til sammen.\nauthors = session.scalars(select(Author)).all()\nfor author in authors:\n    print(author.name, len(author.books))\n\n# select IN-lasting: en ekstra SELECT henter bøkene til alle\n# forfatterne på én gang, med primærnøklene deres i en IN-betingelse.\nstmt = select(Author).options(selectinload(Author.books))\nfor author in session.scalars(stmt).all():\n    print(author.name, len(author.books))\n\n# raise-lasting: tilgang til author.books gir nå en feil\n# i stedet for å sende enda en spørring i det stille.\nstmt = select(Author).options(raiseload(Author.books))\n```\n\nFor en-til-mange- og mange-til-mange-samlinger kaller dokumentasjonen\n`selectinload()` generelt den beste strategien. `joinedload()`, som den kaller\nden mest allsidige strategien, legger en `JOIN` til den opprinnelige setningen,\nsom standard en `LEFT OUTER JOIN`, slik at de relaterte radene kommer i det\nsamme resultatsettet. `raiseload()` finnes for å verne mot uønskede\ninnlastinger, og jokertegnformen `raiseload(\"*\")` utvider vernet til de andre\nrelasjonene også, inkludert dem på objektene setningen faktisk henter.\n\nDjango 6.1 gir det samme valget et eget navn: fetch modes. Når koden rører et\nfelt som den opprinnelige spørringen ikke hentet, for eksempel en fremmednøkkel,\nen en-til-en-relasjon eller et felt som er utelatt med `defer()` eller `only()`,\nhenter standardmodusen `FETCH_ONE` det for akkurat den ene instansen, og\ndokumentasjonen kaller selv resultatet N+1-problemet. `FETCH_PEERS`, som er nytt\ni 6.1, henter det manglende feltet for instansen og for alle de andre instansene\nfra det samme `QuerySet`, ut fra antagelsen om at kode som trenger et felt for\nén rad, som regel trenger det for alle. `FETCH_RAISE` utløser i stedet\n`FieldFetchBlocked`. En modus settes per `QuerySet`, som i\n`Book.objects.fetch_mode(models.FETCH_PEERS)`, eller som standard for en modell\ngjennom en egen manager, og Django kopierer den videre til de relaterte\nobjektene det henter. Der `FETCH_PEERS` ikke passer eller ikke er effektiv nok,\nviser optimaliseringsguiden til `select_related()` og `prefetch_related()`.\n\nSelskapets egne sider trekker grensen lenger inn mot databasen enn de fleste.\n[Teknologioversikten](/nb/tech-stack/) behandler SQL som et fullverdig språk og\nikke noe en ORM genererer, fordi det meste av ytelsesarbeidet selskapet blir\nhentet inn for, ligger der. I arbeidet hos NextMariner førte grunnleggeren\ntanken helt ut med\n[et funksjonsbasert datalag i PostgreSQL](/nb/portfolio/designed-a-function-first-postgresql-data-layer/):\nhver operasjon appen kan utføre, er én av 1 275 lagrede funksjoner fordelt på 34\nskjemaer, og det finnes ingen direkte tabelltilgang fra Go i det hele tatt.\nRollen API-et logger inn som, har `EXECUTE` på de funksjonene og `USAGE` på\nskjemaene deres og ingenting annet, så den kan ikke røre en tabell direkte.\nSiden legger ikke skjul på prisen: et nytt felt krever en endring i en tabell i\ntillegg til i en funksjon, ikke bare en ny linje i en spørring.\n\n## Hvor det går galt\n\n**En løkke sender én spørring per rad.** N+1-mønsteret over ser harmløst ut på\nen liten utviklingsdatabase og gjør en side tregere i takt med antallet rader.\nBestem innlastingen for hver vei gjennom koden som betyr noe, med\n`selectinload()` eller `joinedload()` i SQLAlchemy og `FETCH_PEERS`,\n`select_related()` eller `prefetch_related()` i Django. Sørg deretter for at det\nuplanlagte tilfellet feiler høylytt: `raiseload()` i SQLAlchemy, eller\n`FETCH_RAISE`, som dokumentasjonen til Django beskriver som en måte å hindre\nutilsiktede spørringer i ytelseskritisk kode på.\n\n**Ingen leser SQL-en som ORM-en skriver.** En ORM skriver SQL som ingen på\nteamet har valgt, og den SQL-en forblir usynlig til en side blir treg.\nOptimaliseringsguiden til Django begynner nettopp her: finn ut hvilke spørringer\nen side kjører og hva de koster, bruk `QuerySet.explain()` for å se hvordan\ndatabasen utfører et gitt `QuerySet`, og les `django.db.connection.queries` for\nå se hva Django skriver på vegne av koden. Gjør lesing av den SQL-en til en fast\ndel av gjennomgangen av enhver viktig side eller jobb, og kjør de trege\nsetningene gjennom databasens egen spørringsplan.\n\n**Arbeid som hører hjemme i databasen, kjøres i Python.** Å hente rader bare for\nå filtrere dem, sammenligne to av feltene deres eller summere dem flytter hver\neneste rad over forbindelsen for å gjøre i applikasjonskoden det databasen kunne\ngjort der dataene allerede ligger. Guiden til Django lister opp alternativene:\n`filter()` og `exclude()` for å filtrere i databasen, `F()`-uttrykk for å\nsammenligne felter i samme modell og `annotate()` for å aggregere i databasen.\nSkriving følger samme regel, med `bulk_create()` og `bulk_update()` i stedet for\nén `save()` per objekt, etter at man har sjekket forbeholdene dokumentasjonen\nnevner for begge. Ved et svært stort resultatsett holder et `QuerySet` på alt\ndet har lest, og kan bruke mye minne, og da kan `iterator()` hjelpe.\n\n**Den siste delen tvinges gjennom ORM-en.** Fowlers eget anslag etterlater 10\ntil 20 % av mappingproblemene, og den siste delen krever ifølge ham alltid nøye\narbeid. Å bøye en ORM til den produserer en bestemt setning, gjemmer det\narbeidet inne i generert SQL som ingen har valgt. Skriv de setningene i SQL, og\ngjennomgå dem som all annen kode. Guiden til Django nevner trinnene nedover:\nuttrykket `RawSQL` legger eksplisitt SQL til en spørring, mindre portabelt, men\nkraftigere, og utover det kan et team skrive sin egen SQL for å hente data eller\nfylle modeller. Hold ORM-en til de rutinepregede postene, der den sparer mest og\nkoster minst.\n\n## Les mer\n\n- [Catalog of Patterns of Enterprise Application Architecture](https://martinfowler.com/eaaCatalog/)\n  — Martin Fowlers korte beskrivelser av Active Record, Data Mapper, Unit of\n  Work, Identity Map og Lazy Load.\n- [ORM Hate](https://martinfowler.com/bliki/OrmHate.html)\n  — hvorfor objektrelasjonell mapping er vanskelig, og hvor mye av det et\n  rammeverk kan ta seg av.\n- [Relationship Loading Techniques](https://docs.sqlalchemy.org/en/21/orm/queryguide/relationships.html)\n  — lat lasting, select IN, joined og raise i SQLAlchemy 2.1, og hvilken\n  strategi man bør velge.\n- [Fetch modes](https://docs.djangoproject.com/en/stable/topics/db/fetch-modes/)\n  — `FETCH_ONE`, `FETCH_PEERS` og `FETCH_RAISE`, som er nye i Django 6.1.\n- [Database access optimization](https://docs.djangoproject.com/en/stable/topics/db/optimization/)\n  — profilering, evaluering av `QuerySet`, arbeid i databasen, bulkmetoder og rå\n  SQL.\n\n\u003chttps://engineer.company/nb/glossary/orm/\u003e\n","date_modified":"2026-11-09T21:50:25Z","description":"Hva en ORM gjør mellom objekter og tabeller, hvilke av Fowlers mønstre den bygger på, hva relaterte rader koster å hente, og fire fallgruver.","formats":{"gemtext":"https://engineer.company/nb/glossary/orm/index.gmi","gopher":"https://engineer.company/nb/glossary/orm/gophermap","html":"https://engineer.company/nb/glossary/orm/","json":"https://engineer.company/nb/glossary/orm/index.json","markdown":"https://engineer.company/nb/glossary/orm/index.md","pdf":"https://engineer.company/nb/glossary/orm/index.pdf"},"kind":"page","language":"nb","title":"Hva er en ORM?","url":"https://engineer.company/nb/glossary/orm/","version":1}