ORMs verstehen: Datenbanken objektorientiert ansprechen

Sobald deine Anwendung mit einer Datenbank spricht, schreibst du schnell viele SQL-Strings von Hand. Das ist fehleranfällig und unübersichtlich. Hier kommt ein ORM (Object-Relational Mapper) ins Spiel: Es übersetzt zwischen deinen Objekten im Code und den Tabellen der Datenbank. In diesem Beitrag erkläre ich dir, wie ORMs funktionieren, welche Vorteile sie bringen und worauf du achten solltest.

Was macht ein ORM?

Ein ORM bildet Datenbanktabellen auf Klassen oder Modelle ab. Eine Zeile in der Tabelle wird zu einem Objekt, eine Spalte zu einer Eigenschaft. Statt SQL zu schreiben, rufst du Methoden auf. Das ORM erzeugt im Hintergrund das passende SQL und wandelt die Ergebnisse zurück in Objekte.

Der Vorteil: Du bleibst in deiner Programmiersprache und musst nicht ständig den Kontext zu SQL wechseln. Bekannte ORMs in der JavaScript-Welt sind Prisma, Sequelize und TypeORM.

SQL von Hand vs. ORM

Schauen wir uns denselben Vorgang einmal direkt mit SQL und einmal mit einem ORM an. Zuerst die klassische SQL-Variante:

SELECT * FROM nutzer WHERE alter > 18 ORDER BY name ASC;

Mit einem ORM wie Prisma sieht dieselbe Abfrage so aus:

const erwachsene = await prisma.nutzer.findMany({
  where: { alter: { gt: 18 } },
  orderBy: { name: "asc" }
});

Du arbeitest mit echten JavaScript-Objekten, bekommst Autovervollständigung und das ORM kümmert sich um das korrekte Escaping der Werte.

Modelle definieren

Bevor du Daten abfragst, beschreibst du deine Tabellen als Modelle. Bei Prisma geschieht das in einer Schema-Datei:

model Nutzer {
  id     Int     @id @default(autoincrement())
  name   String
  email  String  @unique
  alter  Int
  posts  Post[]
}

model Post {
  id        Int     @id @default(autoincrement())
  titel     String
  autor     Nutzer  @relation(fields: [autorId], references: [id])
  autorId   Int
}

Hier siehst du auch eine Beziehung: Ein Nutzer hat viele Posts. Das ORM kennt diese Verknüpfung und kann zusammengehörige Daten gemeinsam laden.

Datensätze erstellen und verknüpfen

Neue Datensätze legst du mit Methoden wie create an. Beziehungen kannst du dabei direkt mitschreiben:

// Einen Nutzer mit direkt verbundenem Post anlegen
const neuerNutzer = await prisma.nutzer.create({
  data: {
    name: "Lena",
    email: "lena@example.com",
    alter: 27,
    posts: {
      create: [{ titel: "Mein erster Beitrag" }]
    }
  },
  include: { posts: true }
});

console.log(neuerNutzer.posts.length); // 1

Mit include sagst du dem ORM, dass es die verbundenen Posts gleich mitliefern soll. Das spart dir eine zweite Abfrage.

Das N+1-Problem

Ein klassischer Fallstrick bei ORMs ist das N+1-Problem. Es entsteht, wenn du in einer Schleife für jedes Objekt eine weitere Abfrage auslöst:

// Schlecht: 1 Abfrage fuer Nutzer + N Abfragen fuer Posts
const nutzer = await prisma.nutzer.findMany();
for (const n of nutzer) {
  const posts = await prisma.post.findMany({ where: { autorId: n.id } });
  console.log(n.name, posts.length);
}

// Besser: alles in einer Abfrage mit include
const mitPosts = await prisma.nutzer.findMany({ include: { posts: true } });

Die untere Variante lädt alles effizient. Behalte das im Hinterkopf, sonst wird deine App bei vielen Datensätzen unnötig langsam.

Wann lohnt sich ein ORM?

Ein ORM nimmt dir viel Routinearbeit ab und macht deinen Code lesbarer. Es lohnt sich besonders, wenn:

• du viele einfache bis mittlere Abfragen hast,
• dein Team Typsicherheit und Autovervollständigung schätzt,
• du Migrationen (Änderungen am Datenbankschema) versioniert verwalten willst.

Bei hochkomplexen, performancekritischen Abfragen greifst du manchmal trotzdem zu rohem SQL. Die meisten ORMs erlauben das als Notausgang, sodass du beides kombinieren kannst.

Fazit

Ein ORM schlägt die Brücke zwischen objektorientiertem Code und relationalen Datenbanken. Du arbeitest mit Modellen statt mit SQL-Strings, profitierst von Typsicherheit und sauberen Beziehungen. Achte auf Stolperfallen wie das N+1-Problem und wisse, wann roher SQL die bessere Wahl ist. Probiere Prisma oder Sequelize in einem kleinen Projekt aus, dann merkst du schnell, wie viel angenehmer die Datenbankarbeit wird.