{"canonical_url":"https://engineer.company/da/glossary/orm/","content_markdown":"# ORM\n\n## Hvad det er\n\nEn ORM, kort for object-relational mapper, er et bibliotek, der kobler\ntabellerne i en relationel database til klasser i applikationskoden og rækkerne\ni dem til objekter. Koden beder om en forfatter og får et `Author`-objekt\ntilbage, ændrer en af dets attributter og gemmer det, og ORM-biblioteket skriver\nde `SELECT`-, `INSERT`- og `UPDATE`-sætninger, der gør arbejdet. Djangos\nmodeller og SQLAlchemys ORM, begge skrevet i Python, er to kendte eksempler, og\ndet er dem, denne artikel bygger på.\n\nKortlægningen er nødvendig, fordi de to sider organiserer data forskelligt.\nMartin Fowler siger det ligeud i sin beskrivelse af mønstret Data Mapper:\nobjekter og relationelle databaser strukturerer data på hver sin måde, og dele\naf en objektmodel, som samlinger og nedarvning, har intet modstykke i en\nrelationel database. At flytte data mellem de to bliver et problem i sig selv,\nog en ORM er et færdigt svar på det.\n\nDelene af det svar fik navne i Fowlers bog Patterns of Enterprise Application\nArchitecture fra 2003, hvis mønsterkatalog ligger frit tilgængeligt på nettet.\nTo mønstre beskriver den overordnede form. Active Record er et objekt, der\nindkapsler én række i en tabel, selv står for sin databaseadgang og bærer\ndomænelogikken for de data; ifølge Djangos designfilosofi følger modellerne i\nDjango netop det mønster. Data Mapper er et separat lag, der flytter data mellem\nobjekterne og databasen og holder dem uafhængige af hinanden, så objekterne ikke\nbehøver at vide, at der overhovedet findes en database. Rundt om dem ligger en\nrække mindre mønstre. Identity Map sørger for, at hvert objekt kun indlæses én\ngang. Unit of Work holder en liste over de objekter, et stykke arbejde har\nændret, og skriver ændringerne ud samlet. Lazy Load er et objekt, der kun rummer\nen del af de data, koden skal bruge, men ved, hvordan resten hentes. SQLAlchemys\ndokumentation nævner to af dem direkte: dens `Session` holder indlæste objekter\ni et identity map, med kun ét objekt pr. primærnøgle, og dens måde at samle\nændringer og flushe dem til databasen på er unit of work-mønstret.\n\n## Hvorfor det betyder noget\n\nDen første grund er den mængde kode, en ORM sparer. I sit essay ORM Hate fra\n2012 kalder Fowler problemet med objektrelationel mapping svært: det handler om\nat holde to vidt forskellige repræsentationer af de samme data i takt, og en\nændring på den ene side skal føres over til den anden. Hans skøn er, at en ORM\nklarer omkring 80 til 90 % af mappingproblemerne, og han mener, at et framework,\nder sparer et team for 80 % af det arbejde, er værd at have, også selv om det\nstopper dér. Hver tabel, teamet ikke mapper i hånden, er ét sted mindre, hvor en\nkolonne kan blive læst ind i den forkerte attribut.\n\nDen anden grund er sammenhæng inde i et kørende program. Med et identity map\nreturnerer to databaseforespørgsler, der finder den samme række, det samme\nobjekt, så en ændring gennem den ene reference kan ses gennem den anden;\nSQLAlchemys dokumentation viser det ved at hente den samme primærnøgle to gange\nog få præcis det samme objekt tilbage. Med en unit of work samler\nORM-biblioteket ventende indsættelser, opdateringer og sletninger og skriver dem\nifølge SQLAlchemys funktionsliste ud i én samlet omgang, så applikationskoden\nikke selv skal huske, hvilke objekter den har rørt. Django vælger med vilje det\nmodsatte: frameworkets designfilosofi kræver et eksplicit kald til `save()` i\nstedet for, at frameworket gemmer i det skjulte, så der sendes så få\nSQL-sætninger som muligt.\n\nDen tredje grund er, hvor grænsen går. Fowler beskriver en god ORM som en, der\ntager sig af det kedelige arbejde, men giver adgang til et mandehul ned til SQL,\nnår der er brug for det, og han siger ligeud, at den, der bygger på en\nrelationel database, skal vide, hvordan sådan en virker. Djangos designfilosofi\nsiger det samme fra frameworkets side: databasens API skal vide, at det er en\ngenvej og ikke nødvendigvis hele svaret, og frameworket skal gøre det let at\nskrive egen SQL, hvad enten det er hele sætninger eller blot en\n`WHERE`-betingelse. En ORM gør sig fortjent til sin plads på den rutineprægede\ndel af dataadgangen; resten er der, hvor et team bruger sine SQL-evner.\n\n## Sådan ser det ud i praksis\n\nDen omkostning, en ORM oftest skjuler, er antallet af forespørgsler, den sender.\nI SQLAlchemy 2.1 indlæses relationer dovent som standard: de relaterede objekter\nhentes første gang, koden rører attributten. Dokumentationen siger det ligeud:\nfor N indlæste objekter betyder adgang til deres dovent indlæste attributter N+1\n`SELECT`-sætninger. Eksemplet herunder forudsætter, at klasserne `Author` og\n`Book` allerede er mappet med en en-til-mange-relation, `Author.books`, og\ngennemløber forfatterne på tre måder.\n\n```python\nfrom sqlalchemy import select\nfrom sqlalchemy.orm import raiseload, selectinload\n\n# Standarden: én SELECT til forfatterne og så én mere for hver\n# forfatter, hvis bøger løkken rører, i alt N+1 sætninger.\nauthors = session.scalars(select(Author)).all()\nfor author in authors:\n    print(author.name, len(author.books))\n\n# select IN-indlæsning: en ekstra SELECT henter alle forfatternes\n# bøger på én gang med deres primærnøgler 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-indlæsning: adgang til author.books giver nu en fejl\n# i stedet for stille at sende endnu en forespørgsel.\nstmt = select(Author).options(raiseload(Author.books))\n```\n\nTil en-til-mange- og mange-til-mange-samlinger kalder dokumentationen\n`selectinload()` generelt den bedste strategi. `joinedload()`, som den kalder\nden mest alsidige strategi, føjer en `JOIN` til den oprindelige sætning, som\nstandard en `LEFT OUTER JOIN`, så de relaterede rækker kommer med i det samme\nresultatsæt. `raiseload()` findes for at beskytte mod uønskede indlæsninger, og\njokertegnsformen `raiseload(\"*\")` udvider beskyttelsen til de øvrige relationer,\nogså dem på de objekter, sætningen faktisk henter.\n\nDjango 6.1 giver det samme valg sit eget navn: fetch modes. Når koden rører et\nfelt, som den oprindelige forespørgsel ikke hentede, for eksempel en\nfremmednøgle, en en-til-en-relation eller et felt, der er udeladt med `defer()`\neller `only()`, henter standardtilstanden `FETCH_ONE` det for netop den ene\ninstans, og dokumentationen kalder selv resultatet for N+1-problemet.\n`FETCH_PEERS`, der er nyt i 6.1, henter det manglende felt for instansen og for\nalle de andre instanser fra det samme `QuerySet` ud fra den antagelse, at kode,\nder har brug for et felt på én række, som regel har brug for det på dem alle.\n`FETCH_RAISE` udløser i stedet `FieldFetchBlocked`. En tilstand sættes pr.\n`QuerySet`, som i `Book.objects.fetch_mode(models.FETCH_PEERS)`, eller som\nstandard for en model gennem en tilpasset manager, og Django kopierer den videre\ntil de relaterede objekter, det henter. Hvor `FETCH_PEERS` ikke er passende\neller effektiv nok, henviser optimeringsguiden til `select_related()` og\n`prefetch_related()`.\n\nVirksomhedens egne sider trækker grænsen længere ind mod databasen end de\nfleste. Dens [oversigt over teknologier](/da/tech-stack/) behandler SQL som et\nfuldgyldigt sprog og ikke som noget, en ORM genererer, fordi det meste af det\nperformancearbejde, virksomheden hentes ind til, ligger dér. I sit arbejde hos\nNextMariner førte grundlæggeren tanken helt igennem med\n[et funktionsbaseret datalag i PostgreSQL](/da/portfolio/designed-a-function-first-postgresql-data-layer/):\nhver operation, appen kan udføre, er én af 1.275 lagrede funktioner fordelt på\n34 skemaer, og der er slet ingen direkte tabeladgang fra Go. Den rolle,\nAPI-laget logger ind som, har `EXECUTE` på de funktioner og `USAGE` på deres\nskemaer og intet andet, så den kan ikke røre en tabel direkte. Siden lægger ikke\nskjul på prisen: et nyt felt kræver en ændring i en tabel såvel som i en\nfunktion og ikke blot en ekstra linje i en databaseforespørgsel.\n\n## Hvor det går galt\n\n**En løkke sender én forespørgsel pr. række.** N+1-mønstret ovenfor ser harmløst\nud på en lille udviklingsdatabase og gør en side langsommere i takt med antallet\naf rækker. Beslut indlæsningen for hver vej gennem koden, der betyder noget, med\n`selectinload()` eller `joinedload()` i SQLAlchemy og `FETCH_PEERS`,\n`select_related()` eller `prefetch_related()` i Django. Få derefter det\nuplanlagte tilfælde til at fejle højlydt: `raiseload()` i SQLAlchemy eller\n`FETCH_RAISE`, som Djangos dokumentation beskriver som en måde at forhindre\nutilsigtede forespørgsler i ydelseskritisk kode på.\n\n**Ingen læser den SQL, som ORM-biblioteket skriver.** En ORM skriver SQL, som\ningen på teamet har valgt, og den SQL forbliver usynlig, indtil en side bliver\nlangsom. Djangos optimeringsguide begynder netop her: find ud af, hvilke\nforespørgsler en side kører, og hvad de koster, brug `QuerySet.explain()` til at\nse, hvordan databasen udfører et givet `QuerySet`, og læs\n`django.db.connection.queries` for at se, hvad Django skriver på kodens vegne.\nGør det til en fast del af gennemgangen af enhver vigtig side eller ethvert\nvigtigt job at læse den SQL, og kør de langsomme sætninger gennem databasens\negen forespørgselsplan.\n\n**Arbejde, der hører hjemme i databasen, kører i Python.** At hente rækker blot\nfor at filtrere dem, sammenligne to af deres felter eller lægge dem sammen\nflytter hver eneste række over forbindelsen for at gøre i applikationskoden,\nhvad databasen kunne gøre dér, hvor dataene allerede ligger. Djangos guide\nnævner alternativerne: `filter()` og `exclude()` til at filtrere i databasen,\n`F()`-udtryk til at sammenligne felter i samme model og `annotate()` til at\naggregere i databasen. Skrivninger følger samme regel, med `bulk_create()` og\n`bulk_update()` i stedet for ét `save()` pr. objekt, efter at man har tjekket de\nforbehold, dokumentationen nævner for begge. Ved et meget stort resultatsæt\nholder et `QuerySet` fast i alt, det har læst, og kan bruge meget hukommelse, og\nher kan `iterator()` hjælpe.\n\n**Den sidste del tvinges gennem ORM-biblioteket.** Fowlers eget skøn efterlader\n10 til 20 % af mappingproblemerne, og den sidste del kræver ifølge ham altid\nomhyggeligt arbejde. At bøje en ORM, indtil den producerer en bestemt sætning,\ngemmer det arbejde inde i genereret SQL, som ingen har valgt. Skriv de sætninger\ni SQL, og gennemgå dem som al anden kode. Djangos guide nævner trinene nedad:\nudtrykket `RawSQL` føjer eksplicit SQL til en forespørgsel, mindre portabelt,\nmen mere kraftfuldt, og derudover kan et team skrive sin egen SQL til at hente\ndata eller fylde modeller. Hold ORM-biblioteket til de rutineprægede poster,\nhvor det sparer mest og koster mindst.\n\n## Læs mere\n\n- [Catalog of Patterns of Enterprise Application Architecture](https://martinfowler.com/eaaCatalog/)\n  — Martin Fowlers korte beskrivelser af Active Record, Data Mapper, Unit of\n  Work, Identity Map og Lazy Load.\n- [ORM Hate](https://martinfowler.com/bliki/OrmHate.html)\n  — hvorfor objektrelationel mapping er svært, og hvor meget af det et framework\n  kan tage sig af.\n- [Relationship Loading Techniques](https://docs.sqlalchemy.org/en/21/orm/queryguide/relationships.html)\n  — doven indlæsning, select IN, joined og raise i SQLAlchemy 2.1, og hvilken\n  strategi man skal vælge.\n- [Fetch modes](https://docs.djangoproject.com/en/stable/topics/db/fetch-modes/)\n  — `FETCH_ONE`, `FETCH_PEERS` og `FETCH_RAISE`, der er nye i Django 6.1.\n- [Database access optimization](https://docs.djangoproject.com/en/stable/topics/db/optimization/)\n  — profilering, evaluering af `QuerySet`, arbejde i databasen, bulkmetoder og\n  rå SQL.\n\n\u003chttps://engineer.company/da/glossary/orm/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"Hvad en ORM gør mellem objekter og tabeller, hvilke af Fowlers mønstre den bygger på, hvad relaterede rækker koster at hente, og fire faldgruber.","formats":{"gemtext":"https://engineer.company/da/glossary/orm/index.gmi","gopher":"https://engineer.company/da/glossary/orm/gophermap","html":"https://engineer.company/da/glossary/orm/","json":"https://engineer.company/da/glossary/orm/index.json","markdown":"https://engineer.company/da/glossary/orm/index.md","pdf":"https://engineer.company/da/glossary/orm/index.pdf"},"kind":"page","language":"da","title":"Hvad er en ORM?","url":"https://engineer.company/da/glossary/orm/","version":1}