32 CRUD: Create, Read, Update, Delete

MongoDB unterstützt die grundlegenden CRUD-Operationen, um Daten in einer Datenbank zu erstellen, zu lesen, zu aktualisieren und zu löschen. Hier finden Sie eine detaillierte Anleitung zur Implementierung dieser Operationen.

32.1 Create: Daten einfügen

32.1.1 Einzelnes Dokument einfügen

Die Methode insertOne() fügt ein einzelnes Dokument in eine Sammlung ein.

db.meineSammlung.insertOne({
    name: "Max",
    alter: 30,
    beruf: "Entwickler"
});

Ergebnis: Ein Objekt mit der automatisch generierten _id.

32.1.2 Mehrere Dokumente einfügen

Die Methode insertMany() fügt mehrere Dokumente gleichzeitig ein.

db.meineSammlung.insertMany([
    { name: "Anna", alter: 25, beruf: "Designer" },
    { name: "Tom", alter: 35, beruf: "Manager" }
]);

Optionale Parameter: - writeConcern: Legt das Schreibsicherheitsniveau fest. - ordered: Bestimmt, ob die Einfügungen nacheinander (standardmäßig true) oder parallel (false) ausgeführt werden.

32.2 Read: Daten abfragen

32.2.1 Alle Dokumente abfragen

Die Methode find() ruft alle Dokumente in einer Sammlung ab.

db.meineSammlung.find();

32.2.2 Mit Filtern arbeiten

Sie können Abfragen mit JSON-ähnlicher Syntax definieren:

db.meineSammlung.find({ beruf: "Entwickler" });

32.2.3 Projektion

Bestimmen Sie, welche Felder zurückgegeben werden sollen:

db.meineSammlung.find(
    { beruf: "Entwickler" },
    { name: 1, _id: 0 }
);

32.2.4 Ein Dokument abfragen

Verwenden Sie findOne(), um nur das erste passende Dokument zu erhalten:

db.meineSammlung.findOne({ name: "Max" });

32.3 Update: Daten ändern

32.3.1 Einzelnes Dokument aktualisieren

Mit updateOne() können Sie ein einzelnes Dokument aktualisieren:

db.meineSammlung.updateOne(
    { name: "Max" },
    { $set: { beruf: "Senior Entwickler" } }
);

32.3.2 Mehrere Dokumente aktualisieren

Mit updateMany() können Sie mehrere Dokumente gleichzeitig aktualisieren:

db.meineSammlung.updateMany(
    { beruf: "Manager" },
    { $set: { abteilung: "Vertrieb" } }
);

32.3.3 Operatoren

$set: Aktualisiert oder fügt ein Feld hinzu.
$unset: Entfernt ein Feld.
$inc: Erhöht einen numerischen Wert.

Beispiel:

db.meineSammlung.updateOne(
    { name: "Anna" },
    { $inc: { alter: 1 } }
);

32.4 Delete: Daten löschen

32.4.1 Einzelnes Dokument löschen

Die Methode deleteOne() entfernt ein einzelnes Dokument:

db.meineSammlung.deleteOne({ name: "Max" });

32.4.2 Mehrere Dokumente löschen

Die Methode deleteMany() entfernt alle passenden Dokumente:

db.meineSammlung.deleteMany({ beruf: "Manager" });

32.5 Zusammenfassung

Operation	Methode	Beschreibung
Create	`insertOne()`	Fügt ein einzelnes Dokument ein.
	`insertMany()`	Fügt mehrere Dokumente ein.
Read	`find()`	Ruft alle passenden Dokumente ab.
	`findOne()`	Ruft ein einzelnes passendes Dokument ab.
Update	`updateOne()`	Aktualisiert ein einzelnes Dokument.
	`updateMany()`	Aktualisiert mehrere Dokumente.
Delete	`deleteOne()`	Löscht ein einzelnes Dokument.
	`deleteMany()`	Löscht mehrere Dokumente.

MongoDB bietet durch diese Methoden eine intuitive Möglichkeit, mit Dokumenten zu arbeiten. Verwenden Sie Filter und Operatoren, um Abfragen und Änderungen präzise zu steuern.

32.6 Read: Abfragen von Daten

Das Abfragen von Daten in MongoDB ist flexibel und leistungsstark. MongoDB bietet Methoden und Operatoren, um Daten präzise und effizient abzurufen.

32.6.1 Grundlegende Abfragen

32.6.1.1 Alle Dokumente abrufen

db.meineSammlung.find();

32.6.1.2 Abfrage mit Bedingungen

db.meineSammlung.find({ typ: "KI" });

32.6.2 Feldauswahl (Projektion)

32.6.2.1 Bestimmte Felder anzeigen

db.meineSammlung.find({}, { name: 1, typ: 1, _id: 0 });

Das _id-Feld wird standardmäßig zurückgegeben. Um es auszuschließen, setzen Sie _id: 0.

32.6.3 Abfrageoperatoren

MongoDB bietet Operatoren zur Definition komplexer Abfragebedingungen.

32.6.3.1 Vergleichsoperatoren

$gt: Größer als
$gte: Größer oder gleich
$lt: Kleiner als
$lte: Kleiner oder gleich
$ne: Ungleich

db.meineSammlung.find({ alter: { $gt: 30 } });

32.6.3.2 Logische Operatoren

$or: Mindestens eine Bedingung muss erfüllt sein.
$and: Alle Bedingungen müssen erfüllt sein.
$not: Negiert eine Bedingung.

db.meineSammlung.find({
  $or: [{ alter: { $lt: 20 } }, { typ: "KI" }]
});

32.6.3.3 Array-Abfragen

$in: Werte aus einer Liste
$all: Alle Werte müssen vorhanden sein
$size: Länge eines Arrays

db.meineSammlung.find({ hobbies: { $in: ["Lesen", "Schreiben"] } });

32.6.3.4 Abfragen eingebetteter Dokumente

Mit der Punkt-Notation greifen Sie auf Felder in eingebetteten Dokumenten zu:

db.meineSammlung.find({ "adresse.stadt": "Berlin" });

32.6.4 Sortieren, Limitieren und Überspringen

32.6.4.1 Sortieren

db.meineSammlung.find().sort({ name: 1 }); // Aufsteigend sortieren
db.meineSammlung.find().sort({ name: -1 }); // Absteigend sortieren

32.6.4.2 Limitieren der Ergebnisse

db.meineSammlung.find().limit(5);

32.6.4.3 Überspringen von Dokumenten

db.meineSammlung.find().skip(10);

32.6.4.4 Kombination von Sortieren, Limitieren und Überspringen

db.meineSammlung.find().sort({ alter: -1 }).limit(10).skip(5);

32.6.5 Cursor-Methoden

find() gibt einen Cursor zurück, der die Ergebnisse iterativ abrufen kann.

32.6.5.1 Iteration mit `while`

const cursor = db.meineSammlung.find();
while (cursor.hasNext()) {
  printjson(cursor.next());
}

32.6.5.2 Iteration mit `forEach`

db.meineSammlung.find().forEach(dokument => printjson(dokument));

32.6.6 Zählen und Filtern

32.6.6.1 Dokumente zählen

db.meineSammlung.countDocuments({ typ: "KI" });

32.6.6.2 Einzigartige Werte abrufen

db.meineSammlung.distinct("typ");

32.6.7 Aggregations-Framework

Das Aggregations-Framework ermöglicht komplexe Datenanalysen und Transformationen.

32.6.7.1 Beispiel: Gruppierung und Durchschnitt

db.meineSammlung.aggregate([
  { $match: { typ: "KI" } },
  { $group: { _id: "$typ", durchschnittAlter: { $avg: "$alter" } } }
]);

32.6.8 Beispiel: Vollständige Abfrage

32.6.8.1 Abfrage mit Bedingungen, Projektion, Sortierung und Limitierung

db.meineSammlung.find(
  { typ: "KI", alter: { $gte: 25 } },
  { name: 1, alter: 1, _id: 0 }
).sort({ alter: -1 }).limit(10);

32.7 Update: Ändern von Daten

In MongoDB können Daten flexibel und effizient aktualisiert werden. Mit den Methoden und Operatoren für Updates lassen sich gezielte Änderungen an einzelnen oder mehreren Dokumenten vornehmen. Hier sind die wichtigsten Konzepte und Beispiele.

32.7.1 Grundlegende Methoden

32.7.1.1 `updateOne()`

Aktualisiert das erste Dokument, das die Kriterien erfüllt.

db.meineSammlung.updateOne(
    { name: "Max" },
    { $set: { beruf: "Senior Entwickler" } }
);

32.7.1.2 `updateMany()`

Aktualisiert alle Dokumente, die die Kriterien erfüllen.

db.meineSammlung.updateMany(
    { beruf: "Entwickler" },
    { $set: { abteilung: "Technik" } }
);

32.7.1.3 `replaceOne()`

Ersetzt ein ganzes Dokument durch ein neues.

db.meineSammlung.replaceOne(
    { name: "Max" },
    { name: "Max Mustermann", beruf: "Manager", alter: 40 }
);

32.7.2 Update-Operatoren

MongoDB bietet leistungsstarke Operatoren, um Updates präzise durchzuführen.

32.7.2.1 Feldwerte setzen oder aktualisieren: `$set`

db.meineSammlung.updateOne(
    { name: "Max" },
    { $set: { beruf: "Manager" } }
);

32.7.2.2 Felder hinzufügen oder entfernen: `$unset`

db.meineSammlung.updateOne(
    { name: "Max" },
    { $unset: { abteilung: "" } }
);

32.7.2.3 Zahlenwerte erhöhen oder verringern: `$inc`

db.meineSammlung.updateOne(
    { name: "Max" },
    { $inc: { alter: 1 } }
);

32.7.2.4 Werte zu Arrays hinzufügen: `$push`

db.meineSammlung.updateOne(
    { name: "Max" },
    { $push: { projekte: "Neues Projekt" } }
);

32.7.2.5 Werte aus Arrays entfernen: `$pull`

db.meineSammlung.updateOne(
    { name: "Max" },
    { $pull: { projekte: "Altes Projekt" } }
);

32.7.3 Upsert: Update oder Insert

Wenn ein Dokument nicht existiert, kann es durch einen Upsert erstellt werden. Aktivieren Sie dies mit der Option { upsert: true }:

db.meineSammlung.updateOne(
    { name: "Anna" },
    { $set: { beruf: "Designer", alter: 28 } },
    { upsert: true }
);

32.7.4 Beispiele für komplexe Updates

32.7.4.1 Mehrere Felder aktualisieren

db.meineSammlung.updateMany(
    { abteilung: "Technik" },
    {
        $set: { status: "aktiv" },
        $inc: { anzahlMitarbeiter: 5 },
        $push: { tags: "neuesTag" }
    }
);

32.7.4.2 Bedingte Updates mit `$addToSet`

Fügt ein Element zu einem Array hinzu, wenn es noch nicht vorhanden ist.

db.meineSammlung.updateOne(
    { name: "Max" },
    { $addToSet: { projekte: "Innovationsprojekt" } }
);

32.7.4.3 Updates basierend auf eingebetteten Feldern

db.meineSammlung.updateOne(
    { "adresse.stadt": "Berlin" },
    { $set: { "adresse.postleitzahl": "10115" } }
);

32.7.5 Optionen für Updates

upsert: Führt ein Insert durch, falls kein Dokument die Kriterien erfüllt.
arrayFilters: Ermöglicht das gezielte Aktualisieren von Elementen in Arrays.

Beispiel mit arrayFilters:

db.meineSammlung.updateOne(
    { projekte: { $elemMatch: { status: "offen" } } },
    { $set: { "projekte.$[elem].status": "abgeschlossen" } },
    { arrayFilters: [{ "elem.status": "offen" }] }
);

32.8 Delete: Löschen von Daten

MongoDB bietet leistungsfähige und intuitive Methoden zum Löschen von Daten. Dabei können einzelne oder mehrere Dokumente aus einer Sammlung entfernt werden, abhängig von den Abfragekriterien.

32.8.1 Einzelnes Dokument löschen

Die Methode deleteOne() löscht das erste Dokument, das den Abfragekriterien entspricht:

db.meineSammlung.deleteOne({ name: "Max" });

32.8.2 Mehrere Dokumente löschen

Die Methode deleteMany() entfernt alle Dokumente, die den Abfragekriterien entsprechen:

db.meineSammlung.deleteMany({ typ: "Archiv" });

32.8.3 Alle Dokumente löschen

Um alle Dokumente aus einer Sammlung zu entfernen, ohne die Sammlung selbst zu löschen:

db.meineSammlung.deleteMany({});

32.8.4 Löschen mit Sicherheitsüberlegungen

32.8.4.1 Abfrage überprüfen

Vor dem Löschen empfiehlt es sich, die Abfrage mit find() zu überprüfen, um sicherzustellen, dass die richtigen Dokumente ausgewählt werden:

db.meineSammlung.find({ typ: "Archiv" });

32.8.4.2 Backup vor großen Löschvorgängen

Bevor Sie umfangreiche Löschvorgänge durchführen, erstellen Sie ein Backup der Datenbank, um Datenverluste zu vermeiden.

32.8.5 Beispiel: Sicheres Löschen

// Überprüfen, ob die Sammlung nicht leer ist
if (db.meineSammlung.countDocuments({}) > 0) {
    print("Backup empfohlen vor dem Löschen von Daten");

    // Abfrage testen
    print("Zu löschende Dokumente:");
    db.meineSammlung.find({ typ: "Archiv" }).forEach(doc => printjson(doc));

    // Löschen durchführen
    db.meineSammlung.deleteMany({ typ: "Archiv" });

    // Überprüfen der verbleibenden Dokumente
    print("Verbleibende Dokumente: " + db.meineSammlung.countDocuments({}));
} else {
    print("Die Sammlung ist leer oder existiert nicht.");
}

32.8.6 Sammlung löschen

Wenn Sie eine gesamte Sammlung entfernen möchten, einschließlich ihrer Indexe, verwenden Sie die Methode drop():

db.meineSammlung.drop();

Achtung: Diese Aktion löscht unwiderruflich alle Daten und Indexe der Sammlung.

32.8.7 Best Practices

Abfragevalidierung: Vergewissern Sie sich, dass Ihre Abfrage genau die gewünschten Dokumente auswählt.
Schrittweises Löschen: Testen Sie zunächst mit einer kleinen Datenmenge.
Verwenden Sie deleteOne(), wenn möglich: Reduziert das Risiko unbeabsichtigter Massendatenverluste.
Auditieren: Halten Sie eine Historie der Löschvorgänge für spätere Überprüfungen.
Backup: Vor umfangreichen Löschvorgängen ist ein vollständiges Backup unerlässlich.

MongoDB stellt mit deleteOne() und deleteMany() effektive Methoden bereit, um Daten gezielt zu löschen. Die sorgfältige Überprüfung der Abfragen und das Erstellen von Backups sind essenziell, um Datenverluste zu vermeiden und eine hohe Datenintegrität zu gewährleisten.