MongoDB eingebettete Dokumente verwalten

Einführung

In diesem Lab lernen Sie, wie Sie eingebettete Dokumente in MongoDB effektiv verwalten. Eingebettete Dokumente, auch verschachtelte Dokumente genannt, sind ein Kernmerkmal des Datenmodells von MongoDB, das es Ihnen ermöglicht, komplexe, hierarchische Daten innerhalb eines einzigen Dokuments zu speichern. Sie lernen eine Reihe von Techniken kennen, darunter das Erstellen von Dokumenten mit verschachtelten Daten, das Aktualisieren spezifischer Felder darin, das Entfernen von Elementen und das Abfragen dieser komplexen Strukturen. Sie lernen auch, wie Sie eine konsistente Datenstruktur mithilfe der Schema-Validierung erzwingen können. Diese Fähigkeiten sind unerlässlich für die Entwicklung robuster und effizienter Anwendungen mit MongoDB.

Dokumente mit verschachtelten Daten erstellen

In diesem Schritt lernen Sie, wie Sie Dokumente mit verschachtelten Strukturen in MongoDB erstellen. Dies ist eine grundlegende Fähigkeit für die Modellierung zusammengehöriger Daten innerhalb eines einzigen Dokuments.

Öffnen Sie zunächst die MongoDB Shell (mongosh), um mit der Datenbank zu interagieren. Alle nachfolgenden Befehle in diesem Lab werden in dieser Shell ausgeführt, sofern nicht anders angegeben.

mongosh

Wechseln Sie als Nächstes zu einer neuen Datenbank namens bookstore. Wenn diese Datenbank nicht existiert, erstellt MongoDB sie für Sie, sobald Sie dort Daten speichern.

use bookstore

Nun erstellen Sie eine Collection namens books und fügen ein einzelnes Dokument ein. Dieses Dokument enthält verschachtelte Objekte und ein Array von verschachtelten Objekten, die die Details eines Buches darstellen.

db.books.insertOne({
    title: "Advanced MongoDB",
    author: {
        name: "Jane Smith",
        contact: {
            email: "jane.smith@example.com",
            phone: "+1-555-123-4567"
        }
    },
    published: {
        year: 2023,
        publisher: "Tech Publications"
    },
    chapters: [
        { number: 1, title: "Introduction to Nested Documents" },
        { number: 2, title: "Advanced Document Structures" }
    ]
})

In dem gerade erstellten Dokument:

• author und published sind verschachtelte Dokumente (Objekte).
• Das author-Dokument enthält ein weiteres verschachteltes Dokument, contact.
• chapters ist ein Array, das mehrere verschachtelte Dokumente enthält, die jeweils ein Kapitel darstellen.

Um das Dokument anzuzeigen und seine Struktur zu bestätigen, verwenden Sie die Methode find().

db.books.find()

Sie sollten die folgende Ausgabe sehen, die bestätigt, dass das Dokument korrekt eingefügt wurde. _id ist ein eindeutiger Identifikator, der automatisch von MongoDB generiert wird.

[
  {
    _id: ObjectId("..."),
    title: 'Advanced MongoDB',
    author: {
      name: 'Jane Smith',
      contact: {
        email: 'jane.smith@example.com',
        phone: '+1-555-123-4567'
      }
    },
    published: {
      year: 2023,
      publisher: 'Tech Publications'
    },
    chapters: [
      { number: 1, title: 'Introduction to Nested Documents' },
      { number: 2, title: 'Advanced Document Structures' }
    ]
  }
]

Verschachtelte Felder und Array-Elemente aktualisieren

Nachdem Sie Dokumente erstellt haben, müssen Sie oft Teile davon ändern. In diesem Schritt lernen Sie, wie Sie spezifische Felder innerhalb verschachtelter Dokumente und Arrays aktualisieren. Sie sollten sich immer noch in der mongosh-Shell aus dem vorherigen Schritt befinden.

Aktualisieren wir zunächst die Kontaktinformationen des Autors. Dazu verwenden Sie den $set-Operator mit Punktnotation, um den genauen Pfad zu dem Feld anzugeben, das Sie ändern möchten. Dieser Befehl ändert die Telefonnummer und fügt ein neues Feld website hinzu.

db.books.updateOne(
    { title: "Advanced MongoDB" },
    { $set: {
        "author.contact.phone": "+1-888-999-0000",
        "author.contact.website": "www.janesmith.com"
    } }
)

Die Punktnotation "author.contact.phone" weist MongoDB an, in das author-Objekt zu navigieren, dann in das contact-Objekt und das phone-Feld zu aktualisieren.

Als Nächstes fügen Sie mithilfe des $push-Operators ein neues Kapitel zum chapters-Array hinzu.

db.books.updateOne(
    { title: "Advanced MongoDB" },
    { $push: {
        chapters: {
            number: 3,
            title: "MongoDB Advanced Techniques"
        }
    } }
)

Sie können auch ein bestimmtes Element innerhalb eines Arrays aktualisieren. Ändern wir den Titel des ersten Kapitels. Wir verwenden den Positionsoperator $, der als Platzhalter für das erste Array-Element dient, das der Abfragebedingung ("chapters.number": 1) entspricht.

db.books.updateOne(
    { title: "Advanced MongoDB", "chapters.number": 1 },
    { $set: {
        "chapters.$.title": "Introduction to Nested Documents (Revised)"
    } }
)

Um alle Änderungen zu überprüfen, rufen Sie das Dokument erneut ab. Die Methode .pretty() formatiert die Ausgabe lesbarer.

db.books.find({ title: "Advanced MongoDB" }).pretty()

Die Ausgabe zeigt die aktualisierte Telefonnummer, die neue Website, das hinzugefügte dritte Kapitel und den überarbeiteten Titel des ersten Kapitels.

Verschachtelte Felder und Array-Elemente entfernen

In diesem Schritt lernen Sie, wie Sie Teile Ihrer Dokumente entfernen. Dies umfasst das Entfernen spezifischer Felder, ganzer verschachtelter Dokumente und Elemente aus einem Array.

Entfernen wir zunächst das Feld website aus den Kontaktinformationen des Autors mithilfe des $unset-Operators. Der Wert, der $unset übergeben wird (in diesem Fall ein leerer String ""), spielt keine Rolle; der Operator entfernt einfach das angegebene Feld.

db.books.updateOne(
    { title: "Advanced MongoDB" },
    { $unset: { "author.contact.website": "" } }
)

Als Nächstes entfernen Sie ein Element aus einem Array. Entfernen wir das dritte Kapitel (das mit number: 3) aus dem chapters-Array mithilfe des $pull-Operators. Der $pull-Operator entfernt alle Array-Elemente, die der angegebenen Bedingung entsprechen.

db.books.updateOne(
    { title: "Advanced MongoDB" },
    { $pull: {
        chapters: { number: 3 }
    } }
)

Schließlich können Sie ein ganzes verschachteltes Objekt entfernen. Entfernen wir das contact-Objekt aus dem author-Dokument, wiederum mithilfe des $unset-Operators.

db.books.updateOne(
    { title: "Advanced MongoDB" },
    { $unset: { "author.contact": "" } }
)

Um das Ergebnis dieser Entfernungsoperationen zu sehen, fragen Sie das Dokument erneut ab.

db.books.find({ title: "Advanced MongoDB" }).pretty()

Die Ausgabe zeigt, dass das Feld website und das gesamte contact-Objekt entfernt wurden und das chapters-Array nun nur noch zwei Elemente enthält.

Dokumente mit verschachtelten Daten abfragen

Abfragen ist eine grundlegende Datenbankoperation. In diesem Schritt lernen Sie, wie Sie Dokumente basierend auf Werten in verschachtelten Objekten und Arrays abfragen. Um sicherzustellen, dass wir einen sauberen Datensatz für diese Beispiele haben, löschen Sie zuerst die vorhandene books-Collection.

db.books.drop()

Fügen Sie nun einige neue Dokumente mit unterschiedlichen verschachtelten Strukturen ein, um das Abfragen zu üben.

db.books.insertMany([
    {
        title: "MongoDB Essentials",
        author: {
            name: "John Doe",
            experience: { years: 5, specialization: "Database Design" }
        },
        tags: ["beginner", "database", "nosql"],
        chapters: [
            { number: 1, title: "Introduction", pages: 25 },
            { number: 2, title: "Advanced Concepts", pages: 45 }
        ]
    },
    {
        title: "Advanced Database Techniques",
        author: {
            name: "Jane Smith",
            experience: { years: 8, specialization: "Distributed Systems" }
        },
        tags: ["advanced", "distributed", "nosql"],
        chapters: [
            { number: 1, title: "System Design", pages: 35 },
            { number: 2, title: "Performance Optimization", pages: 55 }
        ]
    }
])

Um ein Buch anhand eines Feldes in einem verschachtelten Dokument zu finden, verwenden Sie die Punktnotation. Diese Abfrage findet das von "John Doe" geschriebene Buch.

db.books.find({ "author.name": "John Doe" })

Sie können tiefer in verschachtelte Strukturen eindringen. Diese Abfrage findet Bücher, bei denen die Spezialisierung des Autors "Database Design" ist.

db.books.find({ "author.experience.specialization": "Database Design" })

Um Dokumente zu finden, bei denen ein Array einen bestimmten Wert enthält, können Sie das Array-Feld direkt abfragen. Dies findet alle Bücher, die mit "nosql" getaggt sind.

db.books.find({ tags: "nosql" })

Sie können auch nach Dokumenten suchen, bei denen ein Array-Element eine bestimmte Bedingung erfüllt. Diese Abfrage findet Bücher, die mindestens ein Kapitel mit mehr als 40 Seiten haben, unter Verwendung des Operators $gt (größer als).

db.books.find({ "chapters.pages": { $gt: 40 } })

Schließlich können Sie mehrere Bedingungen kombinieren. Diese Abfrage findet Bücher, die als "advanced" getaggt sind und von einem Autor mit 5 oder mehr Jahren Erfahrung geschrieben wurden ($gte bedeutet größer oder gleich).

db.books.find({
    "author.experience.years": { $gte: 5 },
    tags: "advanced"
})

Dokumentstruktur mit Schema-Validierung erzwingen

Um die Datenkonsistenz zu gewährleisten, ermöglicht MongoDB die Erzwingung einer bestimmten Struktur für Dokumente in einer Collection mithilfe der JSON Schema-Validierung. In diesem Schritt erstellen Sie eine neue Collection mit einem Validator, um sicherzustellen, dass alle Dokumente einer vordefinierten Struktur entsprechen.

Erstellen Sie zunächst eine neue Collection namens courses. Bei der Erstellung übergeben Sie eine Option validator, die die Schema-Regeln enthält.

db.createCollection("courses", {
   validator: {
      $jsonSchema: {
         bsonType: "object",
         required: ["title", "instructor", "duration", "topics"],
         properties: {
            title: {
               bsonType: "string",
               description: "must be a string and is required"
            },
            instructor: {
               bsonType: "object",
               required: ["name", "email"],
               properties: {
                  name: { bsonType: "string" },
                  email: {
                     bsonType: "string",
                     pattern: "^.+@.+$"
                  }
               }
            },
            duration: {
               bsonType: "int",
               minimum: 1,
               maximum: 100
            },
            topics: {
               bsonType: "array",
               minItems: 1,
               items: { bsonType: "string" }
            }
         }
      }
   }
})

Dieses Schema verlangt, dass jedes Dokument einen title, instructor, duration und topics enthält. Es definiert auch den Datentyp für jedes Feld, einschließlich verschachtelter Regeln für das instructor-Objekt und das topics-Array.

Versuchen Sie nun, ein Dokument einzufügen, das diesen Regeln entspricht. Diese Operation sollte erfolgreich sein.

db.courses.insertOne({
   title: "MongoDB Advanced Techniques",
   instructor: {
      name: "Jane Smith",
      email: "jane.smith@example.com"
   },
   duration: 40,
   topics: ["Nested Documents", "Schema Validation"]
})

Versuchen Sie als Nächstes, ein Dokument einzufügen, das gegen die Schema-Regeln verstößt. Dieses Dokument hat einen falschen Datentyp für instructor.name, ein ungültiges E-Mail-Format, eine duration außerhalb des zulässigen Bereichs und ein leeres topics-Array.

db.courses.insertOne({
   title: "Invalid Course",
   instructor: {
      name: 123,
      email: "invalid-email"
   },
   duration: 200,
   topics: []
})

Diese Einfügung schlägt fehl, und MongoDB gibt einen Fehler Document failed validation zurück. Dies verhindert, dass inkonsistente Daten gespeichert werden, und hilft, die Integrität Ihrer Datenbank zu wahren.

Zusammenfassung

In diesem Lab haben Sie die grundlegenden Techniken für die Verwaltung von eingebetteten Dokumenten in MongoDB gelernt. Sie haben mit der Erstellung von Dokumenten mit komplexen verschachtelten Strukturen, einschließlich Objekten und Arrays, begonnen. Anschließend haben Sie das Aktualisieren spezifischer Felder mithilfe der Punktnotation und von Operatoren wie $set und $push geübt. Sie haben auch gelernt, wie Sie Daten mit $unset und $pull entfernen. Darüber hinaus haben Sie untersucht, wie Sie gezielte Abfragen auf verschachtelte Daten durchführen und schließlich, wie Sie die Datenintegrität durch Definition und Anwendung eines JSON Schema-Validators auf eine Collection erzwingen. Diese Fähigkeiten sind entscheidend für die Entwicklung von Anwendungen, die das flexible Dokumentenmodell von MongoDB effektiv nutzen.