{"canonical_url":"https://engineer.company/de/glossary/orm/","content_markdown":"# ORM\n\n## Was es ist\n\nEin ORM, kurz für Object-Relational Mapper, ist eine Bibliothek, die Tabellen einer relationalen Datenbank auf Klassen im Anwendungscode und Tabellenzeilen auf Objekte abbildet. Code fordert einen Autor an und erhält ein `Author`-Objekt, ändert eines seiner Attribute und speichert es. Der ORM schreibt die dafür nötigen `SELECT`-, `INSERT`- und `UPDATE`-Anweisungen. Die Modelle von Django und der ORM von SQLAlchemy, beide in Python geschrieben, sind zwei bekannte Beispiele, auf die sich dieser Artikel stützt.\n\nDie Abbildung ist nötig, weil beide Seiten Daten unterschiedlich organisieren. Martin Fowler formuliert es in seiner Beschreibung des Data-Mapper-Musters deutlich: Objekte und relationale Datenbanken strukturieren Daten auf unterschiedliche Weise. Teile eines Objektmodells, etwa Sammlungen und Vererbung, haben in einer relationalen Datenbank kein Gegenstück. Daten zwischen beiden zu bewegen wird damit zu einem eigenen Problem. Ein ORM bietet dafür eine fertige Lösung.\n\nDie Bestandteile dieser Lösung wurden in Fowlers 2003 erschienenem Buch Patterns of Enterprise Application Architecture benannt. Sein Musterkatalog ist online verfügbar. Zwei Muster beschreiben den grundlegenden Aufbau. Active Record ist ein Objekt, das eine Tabellenzeile umschließt, seine eigenen Datenbankzugriffe erledigt und die Geschäftslogik dieser Daten trägt. Laut Djangos Entwurfsprinzipien folgen seine Modelle diesem Muster. Data Mapper ist eine getrennte Schicht, die Daten zwischen Objekten und Datenbank bewegt und beide voneinander unabhängig hält. Die Objekte müssen dadurch nichts von der Existenz einer Datenbank wissen. Kleinere Muster ergänzen sie. Identity Map stellt sicher, dass jedes Objekt nur einmal geladen wird. Unit of Work führt eine Liste der durch einen Arbeitsvorgang geänderten Objekte und schreibt die Änderungen gemeinsam. Lazy Load ist ein Objekt, das nur einen Teil der vom Code benötigten Daten hält, aber den Rest abrufen kann. Die SQLAlchemy-Dokumentation nennt zwei davon direkt: Die `Session` hält geladene Objekte in einer Identity Map, mit genau einem Objekt für jeden Primärschlüssel. Das Sammeln und gemeinsame Schreiben von Änderungen in die Datenbank folgt dem Unit-of-Work-Muster.\n\n## Warum es wichtig ist\n\nDer erste Grund ist die eingesparte Codemenge. In seinem Essay ORM Hate von 2012 nennt Fowler die objektrelationale Abbildung schwierig: Zwei sehr unterschiedliche Darstellungen derselben Daten müssen übereinstimmen, und eine Änderung auf einer Seite muss auf die andere übertragen werden. Er schätzt, dass ein ORM etwa 80 bis 90 % der Abbildungsprobleme übernimmt. Ein Framework, das einem Team 80 % dieser Arbeit erspart, hält er schon dann für lohnend, wenn es dabei bleibt. Jede Tabelle, die ein Team nicht von Hand abbildet, ist eine Gelegenheit weniger, eine Spalte in das falsche Attribut einzulesen.\n\nDer zweite Grund ist Konsistenz im laufenden Programm. Mit einer Identity Map liefern zwei Abfragen, die dieselbe Zeile finden, dasselbe Objekt zurück. Eine über eine Referenz vorgenommene Änderung ist dadurch auch über die andere sichtbar. Die SQLAlchemy-Dokumentation zeigt dies, indem sie denselben Primärschlüssel zweimal lädt und das identische Objekt erhält. Mit einer Unit of Work sammelt der ORM ausstehende Einfügungen, Änderungen und Löschungen und schreibt sie, wie es die Funktionsübersicht von SQLAlchemy formuliert, gemeinsam in einem Stapel. Der Anwendungscode muss sich deshalb nicht merken, welche Objekte er berührt hat. Django trifft bewusst die gegenteilige Wahl: Seine Entwurfsprinzipien verlangen ein ausdrückliches `save()` statt eines Speicherns im Hintergrund, damit das Framework möglichst wenige SQL-Anweisungen sendet.\n\nDer dritte Grund ist die Lage der Grenze. Fowler beschreibt einen guten ORM als einen, der die Routinearbeit übernimmt und „Zugangsschächte bietet, damit man bei Bedarf hinunter zum SQL gelangt“. Er sagt unmissverständlich, dass jeder, der eine Anwendung auf einer relationalen Datenbank aufbaut, deren Funktionsweise kennen sollte. Djangos Entwurfsprinzipien sagen aus Sicht des Frameworks dasselbe: Die Datenbank-API sollte als Abkürzung statt als vollständige Lösung verstanden werden und das Schreiben von eigenem SQL erleichtern, ob als ganze Anweisung oder als einzelne `WHERE`-Klausel. Ein ORM rechtfertigt seinen Platz beim Großteil der Datenzugriffe, der zur Routine gehört. Für den Rest setzt das Team seine SQL-Kenntnisse ein.\n\n## Wie es in der Praxis aussieht\n\nAm häufigsten verbirgt ein ORM die Zahl seiner Abfragen. In SQLAlchemy 2.1 werden Beziehungen standardmäßig verzögert geladen: Die zugehörigen Objekte werden erst beim ersten Zugriff des Codes auf das Attribut abgerufen. Die Dokumentation nennt die Folge ausdrücklich: Bei N geladenen Objekten führt der Zugriff auf deren verzögert geladene Attribute zu N+1 `SELECT`-Anweisungen. Das folgende Beispiel setzt bereits abgebildete Klassen `Author` und `Book` mit einer Eins-zu-viele-Beziehung `Author.books` voraus und durchläuft die Autoren auf drei Arten.\n\n```python\nfrom sqlalchemy import select\nfrom sqlalchemy.orm import raiseload, selectinload\n\n# The default: one SELECT for the authors, then one more for each\n# author whose books the loop touches, N+1 statements in all.\nauthors = session.scalars(select(Author)).all()\nfor author in authors:\n    print(author.name, len(author.books))\n\n# select IN loading: a second SELECT fetches the books of every\n# author at once, with the authors' primary keys in an IN clause.\nstmt = select(Author).options(selectinload(Author.books))\nfor author in session.scalars(stmt).all():\n    print(author.name, len(author.books))\n\n# raise loading: touching author.books now raises an error\n# instead of quietly sending another query.\nstmt = select(Author).options(raiseload(Author.books))\n```\n\nFür Eins-zu-viele- und Viele-zu-viele-Sammlungen nennt die Dokumentation `selectinload()` im Allgemeinen die beste Strategie. `joinedload()`, laut Dokumentation die vielseitigste Strategie, ergänzt die ursprüngliche Anweisung um einen `JOIN`, standardmäßig einen `LEFT OUTER JOIN`. So kommen die zugehörigen Zeilen im selben Ergebnis an. `raiseload()` schützt vor unerwünschtem Nachladen. Seine Platzhalterform `raiseload(\"*\")` erweitert diesen Schutz auf die übrigen Beziehungen, auch auf die der tatsächlich durch die Anweisung geladenen Objekte.\n\nDjango 6.1 gibt derselben Entscheidung einen eigenen Namen: Fetch-Modi. Greift Code auf ein Feld zu, das die ursprüngliche Abfrage nicht geladen hat, etwa einen Fremdschlüssel, eine Eins-zu-eins-Beziehung oder ein durch `defer()` oder `only()` ausgelassenes Feld, lädt der Standardmodus `FETCH_ONE` es für genau diese eine Instanz. Die Dokumentation selbst nennt das Ergebnis das N+1-Abfrageproblem. Das in 6.1 neue `FETCH_PEERS` lädt das fehlende Feld für die Instanz und jede weitere Instanz desselben `QuerySet`. Dahinter steht die Überlegung, dass Code ein für eine Zeile benötigtes Feld gewöhnlich auch für alle anderen braucht. `FETCH_RAISE` löst stattdessen `FieldFetchBlocked` aus. Ein Modus wird pro `QuerySet` gesetzt, etwa mit `Book.objects.fetch_mode(models.FETCH_PEERS)`, oder über einen eigenen Manager als Standard eines Modells. Django übernimmt ihn für die abgerufenen zugehörigen Objekte. Wo `FETCH_PEERS` nicht passt oder nicht effizient genug ist, verweist der Optimierungsleitfaden auf `select_related()` und `prefetch_related()`.\n\nDie eigenen Seiten des Unternehmens ziehen die Grenze weiter zur Datenbank hin als die meisten Ansätze. Sein [Technologie-Stack](/de/tech-stack/) behandelt SQL als vollwertige Sprache statt als etwas, das ein ORM generiert, weil dort der Großteil der Performancearbeit liegt, für die das Unternehmen hinzugezogen wird. In ihrer Arbeit unter NextMariner führte die Gründerin diesen Ansatz mit [einer funktionsbasierten PostgreSQL-Datenschicht](/de/portfolio/designed-a-function-first-postgresql-data-layer/) konsequent zu Ende: Jede von der Anwendung ausführbare Operation ist eine von 1.275 gespeicherten Funktionen in 34 Schemas. Direkten Tabellenzugriff aus Go gibt es überhaupt nicht. Die Rolle, mit der sich die API anmeldet, hat `EXECUTE` auf diesen Funktionen und `USAGE` auf ihren Schemas und sonst nichts. Sie kann deshalb keine Tabelle direkt ansprechen. Die Seite benennt den Preis offen: Ein neues Feld bedeutet, sowohl eine Tabelle als auch eine Funktion zu ändern, statt einer Abfrage eine Zeile hinzuzufügen.\n\n## Wo es schiefgeht\n\n**Eine Schleife sendet eine Abfrage pro Zeile.** Das N+1-Muster oben wirkt in einer kleinen Entwicklungsdatenbank harmlos und verlangsamt eine Seite mit wachsender Zeilenzahl. Legen Sie für jeden wichtigen Pfad die Ladestrategie fest: mit `selectinload()` oder `joinedload()` in SQLAlchemy und `FETCH_PEERS`, `select_related()` oder `prefetch_related()` in Django. Lassen Sie den ungeplanten Fall anschließend mit einer deutlichen Fehlermeldung scheitern: mit `raiseload()` in SQLAlchemy oder `FETCH_RAISE`, das Djangos Dokumentation als Möglichkeit beschreibt, unbeabsichtigte Abfragen in performancekritischem Code zu verhindern.\n\n**Niemand liest das SQL, das der ORM schreibt.** Ein ORM schreibt SQL, das niemand im Team ausgewählt hat. Dieses SQL bleibt unsichtbar, bis eine Seite langsam wird. Djangos Optimierungsleitfaden beginnt hier: Ermitteln Sie, welche Abfragen eine Seite ausführt und was sie kosten. Mit `QuerySet.explain()` sehen Sie, wie die Datenbank ein bestimmtes `QuerySet` ausführt; mit `django.db.connection.queries`, was Django im Auftrag des Codes schreibt. Machen Sie das Lesen dieses SQL zum Bestandteil jedes Reviews wichtiger Seiten oder Jobs und untersuchen Sie langsame Anweisungen mit dem Abfrageplan der Datenbank selbst.\n\n**Datenbankarbeit läuft in Python.** Wer Zeilen nur lädt, um sie zu filtern, zwei ihrer Felder zu vergleichen oder sie zu summieren, überträgt jede Zeile über die Verbindung. Der Anwendungscode erledigt damit etwas, das die Datenbank dort tun könnte, wo die Daten bereits liegen. Djangos Leitfaden nennt die Alternativen: `filter()` und `exclude()` filtern in der Datenbank, `F()`-Ausdrücke vergleichen Felder desselben Modells, und `annotate()` aggregiert in der Datenbank. Für Schreibzugriffe gilt dasselbe: `bulk_create()` und `bulk_update()` ersetzen ein `save()` pro Objekt, nachdem die in der Dokumentation für beide genannten Einschränkungen geprüft wurden. Bei einer sehr großen Ergebnismenge hält ein `QuerySet` alles Gelesene fest und kann viel Speicher beanspruchen. `iterator()` kann helfen.\n\n**Der letzte Teil wird durch den ORM gezwungen.** Fowlers eigene Schätzung lässt 10 bis 20 % der Abbildungsprobleme übrig. Dieser letzte Teil erfordert nach seinen Worten immer sorgfältige Arbeit. Den ORM so lange zu verbiegen, bis er eine bestimmte Anweisung erzeugt, versteckt diese Arbeit in generiertem SQL, das niemand gewählt hat. Schreiben Sie solche Anweisungen in SQL und prüfen Sie sie wie anderen Code. Djangos Leitfaden nennt die Übergänge zu dieser Ebene: Der Ausdruck `RawSQL` ergänzt eine Abfrage um ausdrückliches SQL, weniger portabel, aber leistungsfähiger. Darüber hinaus kann ein Team eigenes SQL zum Abrufen von Daten oder Befüllen von Modellen schreiben. Behalten Sie den ORM für die Routinefälle, bei denen er am meisten spart und am wenigsten kostet.\n\n## Weiterführende Lektüre\n\n- [Musterkatalog zu Patterns of Enterprise Application Architecture](https://martinfowler.com/eaaCatalog/) — Martin Fowlers Zusammenfassungen von Active Record, Data Mapper, Unit of Work, Identity Map und Lazy Load.\n- [ORM Hate](https://martinfowler.com/bliki/OrmHate.html) — weshalb die objektrelationale Abbildung schwierig ist und wie viel davon ein Framework übernehmen kann.\n- [Techniken zum Laden von Beziehungen](https://docs.sqlalchemy.org/en/21/orm/queryguide/relationships.html) — verzögertes Laden, Select-IN-, Join- und Raise-Laden in SQLAlchemy 2.1 und die Wahl der geeigneten Strategie.\n- [Fetch-Modi](https://docs.djangoproject.com/en/stable/topics/db/fetch-modes/) — `FETCH_ONE`, `FETCH_PEERS` und `FETCH_RAISE`, neu in Django 6.1.\n- [Optimierung von Datenbankzugriffen](https://docs.djangoproject.com/en/stable/topics/db/optimization/) — Profiling, Auswertung von `QuerySet`, Arbeit in der Datenbank, Stapelmethoden und direktes SQL.\n\n\u003chttps://engineer.company/de/glossary/orm/\u003e\n","date_modified":"2026-11-09T21:50:25Z","description":"Ein ORM vermittelt zwischen Objekten und Tabellen. Welche Muster dahinterstehen, was Nachladen kostet und wie Sie vier typische Fehler vermeiden.","formats":{"gemtext":"https://engineer.company/de/glossary/orm/index.gmi","gopher":"https://engineer.company/de/glossary/orm/gophermap","html":"https://engineer.company/de/glossary/orm/","json":"https://engineer.company/de/glossary/orm/index.json","markdown":"https://engineer.company/de/glossary/orm/index.md","pdf":"https://engineer.company/de/glossary/orm/index.pdf"},"kind":"page","language":"de","title":"Was ist ein ORM?","url":"https://engineer.company/de/glossary/orm/","version":1}