Datenbanken

NoSQL mit MongoDB: Dokumentenbasierte Daten

MongoDB speichert Daten als flexible Dokumente statt in starren Tabellen. Du lernst, wie du Collections anlegst, Dokumente abfragst und wann sich NoSQL wirklich lohnt.

Anton

— 2 Min. Lesezeit
Teilen
NoSQL mit MongoDB: Dokumentenbasierte Daten

Wenn du bisher nur mit relationalen Datenbanken wie MySQL oder PostgreSQL gearbeitet hast, fühlt sich MongoDB anfangs ungewohnt an. Statt Tabellen, Zeilen und Spalten arbeitest du hier mit Dokumenten, die wie JSON-Objekte aussehen. In diesem Beitrag zeige ich dir, wie dokumentenbasierte Datenhaltung funktioniert, wie du die wichtigsten Operationen ausführst und wann sich der Umstieg lohnt.

Was ist eine dokumentenbasierte Datenbank?

In MongoDB werden Daten nicht in Tabellen, sondern in Collections gespeichert. Eine Collection enthält viele Dokumente, und jedes Dokument ist im Grunde ein JSON-Objekt (intern BSON, also Binary JSON). Der große Unterschied zu SQL: Es gibt kein festes Schema. Zwei Dokumente in derselben Collection dürfen unterschiedliche Felder haben.

So sieht ein typisches Dokument aus:

{
  "_id": "654a1f2b9c3d",
  "name": "Anna",
  "alter": 29,
  "hobbys": ["Lesen", "Klettern"],
  "adresse": {
    "stadt": "Berlin",
    "plz": "10115"
  }
}

Beachte das verschachtelte adresse-Objekt und das Array hobbys. In SQL müsstest du dafür mehrere Tabellen und Joins anlegen.

Verbindung und Collection anlegen

Mit dem offiziellen Treiber mongodb verbindest du dich in Node.js so:

const { MongoClient } = require("mongodb");

const client = new MongoClient("mongodb://localhost:27017");

async function verbinden() {
  await client.connect();
  const db = client.db("meinShop");
  const nutzer = db.collection("nutzer");
  console.log("Verbunden mit Collection:", nutzer.collectionName);
  return nutzer;
}

verbinden();

Du musst eine Collection nicht explizit erstellen. MongoDB legt sie automatisch an, sobald du das erste Dokument einfügst.

Dokumente einfügen

Zum Einfügen nutzt du insertOne für ein einzelnes Dokument oder insertMany für mehrere:

async function einfuegen(nutzer) {
  await nutzer.insertOne({
    name: "Anna",
    alter: 29,
    hobbys: ["Lesen", "Klettern"]
  });

  await nutzer.insertMany([
    { name: "Ben", alter: 34 },
    { name: "Carla", alter: 22, premium: true }
  ]);
}

Achte darauf, dass Ben kein hobbys-Feld hat und nur Carla ein premium-Feld besitzt. Genau das ist die Flexibilität von NoSQL.

Daten abfragen

Abfragen funktionieren über ein Filter-Objekt. Du beschreibst, welche Eigenschaften die gesuchten Dokumente haben sollen:

// Alle Nutzer ueber 25 Jahre
const erwachsene = await nutzer.find({ alter: { $gt: 25 } }).toArray();

// Genau einen Nutzer finden
const anna = await nutzer.findOne({ name: "Anna" });

// Nur bestimmte Felder zurueckgeben (Projektion)
const namen = await nutzer
  .find({}, { projection: { name: 1, _id: 0 } })
  .toArray();

Operatoren wie $gt (greater than), $lt (less than) oder $in machen die Abfragen mächtig. Mit der Projektion steuerst du, welche Felder geliefert werden.

Aktualisieren und Löschen

Updates erfolgen mit Operatoren wie $set. So vermeidest du, dass du versehentlich das ganze Dokument überschreibst:

// Alter von Anna aendern
await nutzer.updateOne(
  { name: "Anna" },
  { $set: { alter: 30 } }
);

// Ein Hobby hinzufuegen
await nutzer.updateOne(
  { name: "Anna" },
  { $push: { hobbys: "Kochen" } }
);

// Dokument loeschen
await nutzer.deleteOne({ name: "Ben" });

Der Operator $push hängt ein Element an ein Array an, ohne die vorhandenen Werte zu verlieren.

Wann lohnt sich MongoDB?

NoSQL ist kein Ersatz für SQL, sondern eine Ergänzung. MongoDB spielt seine Stärken aus, wenn:

  • deine Datenstruktur sich häufig ändert oder noch nicht feststeht,
  • du verschachtelte Daten ohne komplizierte Joins speichern willst,
  • du horizontal über viele Server skalieren musst.

Wenn deine Daten dagegen stark relational sind und du auf Transaktionssicherheit über viele Tabellen angewiesen bist, bleibt eine klassische relationale Datenbank oft die bessere Wahl.

Fazit

MongoDB bringt dir mit dokumentenbasierter Datenhaltung viel Flexibilität: kein starres Schema, verschachtelte Strukturen und mächtige Abfrageoperatoren. Du hast jetzt gesehen, wie du dich verbindest, Dokumente einfügst, abfragst, änderst und löschst. Mein Tipp: Lege dir eine lokale MongoDB an und spiele die Beispiele durch. So bekommst du am schnellsten ein Gefühl dafür, wann sich NoSQL wirklich lohnt.

Weiterlesen