MongoDB-Referenzen verwenden

Einführung

In diesem Lab werden Sie lernen, wie Sie MongoDB-Referenzen verwenden, um Datenbeziehungen zu entwerfen und die Beziehungen zwischen Eltern- und Kinddokumenten zu verwalten. Sie beginnen mit der Erstellung eines einfachen Bibliothekssystems mit Büchern und Autoren und erkunden dann Techniken zum Verknüpfen von Eltern- und Kinddokumenten, Aktualisieren von Kindreferenzen, Abfragen von Eltern-Kind-Beziehungen und Wahren der referentiellen Integrität. Das Lab behandelt die wichtigsten Grundprinzipien von Dokumentreferenzen in MongoDB und bietet praktische Beispiele, um Ihnen zu helfen, diese Konzepte effektiv zu verstehen und anzuwenden.

Skills Graph

Datenbeziehungen entwerfen

In diesem Schritt werden wir untersuchen, wie wir in MongoDB Datenbeziehungen durch das Erstellen eines praktischen Beispiels von verknüpften Dokumenten entwerfen. Wir modellieren ein einfaches Bibliothekssystem mit Büchern und Autoren.

Das Verständnis von Dokumentreferenzen in MongoDB

MongoDB bietet zwei Hauptweisen, um Beziehungen zwischen Dokumenten zu erstellen:

1. Eingebettete Dokumente
2. Dokumentreferenzen

Für unser Bibliothekssystem werden wir Dokumentreferenzen verwenden, um zu demonstrieren, wie verwandte Daten über Sammlungen verknüpft werden.

Zunächst starten wir die MongoDB-Shell:

mongosh

Jetzt erstellen wir unsere Datenbank und Sammlungen:

use library_database

db.authors.insertOne({
    _id: ObjectId("author1"),
    name: "Jane Austen",
    nationality: "British",
    birthYear: 1775
})

db.books.insertOne({
    title: "Pride and Prejudice",
    author_id: ObjectId("author1"),
    published: 1813,
    genre: "Classic Literature"
})

Die Referenz aufbrechen

Schauen wir uns an, was wir getan haben:

• Wir haben eine authors-Sammlung mit einer eindeutigen _id erstellt
• Wir haben eine books-Sammlung erstellt, die den Autor mithilfe von author_id referenziert
• Das author_id-Feld enthält die _id des entsprechenden Autordokuments

Um unsere Referenzen zu überprüfen, können wir die Dokumente abfragen:

db.authors.findOne({ name: "Jane Austen" })
db.books.findOne({ title: "Pride and Prejudice" })

Beispielausgabe

{
  _id: ObjectId("author1"),
  name: 'Jane Austen',
  nationality: 'British',
  birthYear: 1775
}

{
  _id: ObjectId(...),
  title: 'Pride and Prejudice',
  author_id: ObjectId("author1"),
  published: 1813,
  genre: 'Classic Literature'
}

Wichtige Grundprinzipien von Dokumentreferenzen

• Verwenden Sie _id, um Verbindungen zwischen Dokumenten zu erstellen
• Halten Sie Referenzen einfach und konsistent
• Wählen Sie Referenzen, wenn die Daten groß sind oder häufig geändert werden
• Normalisieren Sie die Daten, um die Duplizierung zu reduzieren

Eltern-Kind-Dokumente verknüpfen

In diesem Schritt erweitern wir unsere Bibliotheksdatenbank, indem wir komplexere Beziehungen zwischen Eltern- und Kinddokumenten erstellen. Wir werden demonstrieren, wie mehrere Bücher einem Autor zugeordnet werden und wie diese Beziehungen effektiv verwaltet werden.

Hinzufügen von mehreren Büchern für einen Autor

Fahren wir mit unserer bestehenden Datenbank fort und fügen wir mehr Bücher von Jane Austen hinzu:

db.books.insertMany([
    {
        title: "Sense and Sensibility",
        author_id: ObjectId("author1"),
        published: 1811,
        genre: "Classic Literature"
    },
    {
        title: "Emma",
        author_id: ObjectId("author1"),
        published: 1815,
        genre: "Classic Literature"
    }
])

Abfragen von verwandten Dokumenten

Um alle Bücher von Jane Austen zu finden, verwenden wir die author_id:

db.books.find({ author_id: ObjectId("author1") })

Beispielausgabe

[
  {
    _id: ObjectId(...),
    title: 'Pride and Prejudice',
    author_id: ObjectId("author1"),
    published: 1813,
    genre: 'Classic Literature'
  },
  {
    _id: ObjectId(...),
    title: 'Sense and Sensibility',
    author_id: ObjectId("author1"),
    published: 1811,
    genre: 'Classic Literature'
  },
  {
    _id: ObjectId(...),
    title: 'Emma',
    author_id: ObjectId("author1"),
    published: 1815,
    genre: 'Classic Literature'
  }
]

Zählen der Bücher eines Autors

Wir können auch die Anzahl der Bücher eines bestimmten Autors zählen:

db.books.countDocuments({ author_id: ObjectId("author1") })

Beispielausgabe

3

Fortgeschrittene Abfragen mit Aggregation

Lassen Sie uns das Aggregierungsframework verwenden, um detailliertere Informationen zu erhalten:

db.books.aggregate([
    { $match: { author_id: ObjectId("author1") } },
    { $group: {
        _id: "$author_id",
        totalBooks: { $sum: 1 },
        earliestPublished: { $min: "$published" },
        latestPublished: { $max: "$published" }
    }}
])

Beispielausgabe

[
  {
    _id: ObjectId("author1"),
    totalBooks: 3,
    earliestPublished: 1811,
    latestPublished: 1815
  }
]

Kindreferenzen aktualisieren

In diesem Schritt werden wir lernen, wie wir in MongoDB Referenzen zwischen Eltern- und Kinddokumenten aktualisieren. Wir werden verschiedene Techniken zur Änderung von Dokumentreferenzen und zum Wahren der Datengüte erkunden.

Hinzufügen eines neuen Autors und Aktualisieren von Buchreferenzen

Zunächst fügen wir einen weiteren Autor zu unserer Datenbank hinzu:

db.authors.insertOne({
    _id: ObjectId("author2"),
    name: "Charles Dickens",
    nationality: "British",
    birthYear: 1812
})

Aktualisieren der Autorreferenz eines einzelnen Buches

Lassen Sie uns ein Buch aktualisieren, um seine Autorreferenz zu ändern:

db.books.updateOne(
    { title: "Emma" },
    { $set: { author_id: ObjectId("author2") } }
)

Überprüfen der Aktualisierung

Überprüfen Sie die Autorreferenz des aktualisierten Buches:

db.books.findOne({ title: "Emma" })

Beispielausgabe

{
  _id: ObjectId(...),
  title: 'Emma',
  author_id: ObjectId("author2"),
  published: 1815,
  genre: 'Classic Literature'
}

Masseneinstellung von Referenzen

Wir können auch mehrere Dokumente gleichzeitig aktualisieren:

db.books.updateMany(
    { author_id: ObjectId("author1") },
    { $set: { genre: "Romantic Novel" } }
)

Überprüfen von mehreren Dokumentaktualisierungen

Überprüfen Sie die Genre-Aktualisierung:

db.books.find({ author_id: ObjectId("author1") })

Beispielausgabe

[
  {
    _id: ObjectId(...),
    title: 'Pride and Prejudice',
    author_id: ObjectId("author1"),
    published: 1813,
    genre: 'Romantic Novel'
  },
  {
    _id: ObjectId(...),
    title: 'Sense and Sensibility',
    author_id: ObjectId("author1"),
    published: 1811,
    genre: 'Romantic Novel'
  }
]

Upsert: Aktualisieren oder Einfügen

Wir können die Upsert-Option verwenden, um ein Dokument zu aktualisieren oder es zu erstellen, wenn es nicht existiert:

db.books.updateOne(
    { title: "Oliver Twist" },
    { $set: {
        author_id: ObjectId("author2"),
        published: 1837,
        genre: "Historical Fiction"
    }},
    { upsert: true }
)

Eltern-Kind-Abfragen

In diesem Schritt werden wir fortgeschrittene Abfrageverfahren zur Abrufung von verwandten Dokumenten aus Eltern- und Kind-Sammlungen in MongoDB untersuchen. Wir werden demonstrieren, wie Sie effektiv verwandte Daten finden und verknüpfen.

Grundlegende Filterabfragen

Lassen Sie uns beginnen, indem wir Bücher von einem bestimmten Autor finden:

db.books.find({ author_id: ObjectId("author1") })

Filtern mit mehreren Bedingungen

Abfragen von Büchern mit mehreren Filtern:

db.books.find({
    author_id: ObjectId("author1"),
    published: { $gt: 1812 }
})

Diese Abfrage findet Bücher von Jane Austen, die nach 1812 veröffentlicht wurden.

Aggregationspipeline für komplexe Abfragen

Verwenden Sie das Aggregierungsframework, um Autor- und Buchinformationen zu verknüpfen:

db.books.aggregate([
    { $lookup: {
        from: "authors",
        localField: "author_id",
        foreignField: "_id",
        as: "author_details"
    }},
    { $match: {
        "author_details.nationality": "British"
    }},
    { $project: {
        title: 1,
        published: 1,
        "author_name": "$author_details.name"
    }}
])

Beispielausgabe

[
  {
    _id: ObjectId(...),
    title: 'Pride and Prejudice',
    published: 1813,
    author_name: ['Jane Austen']
  },
  {
    _id: ObjectId(...),
    title: 'Emma',
    published: 1815,
    author_name: ['Charles Dickens']
  }
]

Sortieren und Begrenzen der Ergebnisse

Abfragen und Sortieren von Büchern nach Veröffentlichungsjahr:

db.books.find()
  .sort({ published: 1 })
  .limit(2)

Dies ruft die zwei frühesten veröffentlichten Bücher ab.

Fortgeschrittenes Filtern mit regulären Ausdrücken

Finden Sie Bücher mit Titeln, die bestimmte Wörter enthalten:

db.books.find({
    title: { $regex: /Sense/, $options: 'i' }
})

Die Option $options: 'i' macht die Suche unempfindlich auf Groß- und Kleinschreibung.

Zählen von verwandten Dokumenten

Zählen Sie die Bücher für jeden Autor:

db.books.aggregate([
    { $group: {
        _id: "$author_id",
        book_count: { $sum: 1 }
    }},
    { $lookup: {
        from: "authors",
        localField: "_id",
        foreignField: "_id",
        as: "author_info"
    }},
    { $project: {
        author_name: "$author_info.name",
        book_count: 1
    }}
])

Beispielausgabe

[
  {
    _id: ObjectId("author1"),
    author_name: ['Jane Austen'],
    book_count: 2
  },
  {
    _id: ObjectId("author2"),
    author_name: ['Charles Dickens'],
    book_count: 2
  }
]

Referenzen aufrechterhalten

In diesem letzten Schritt werden wir Strategien zur Aufrechterhaltung von Dokumentreferenzen in MongoDB untersuchen, wobei wir uns auf die Datengüte, die Bereinigung und die bewährten Praktiken bei der Verwaltung von Beziehungen zwischen Sammlungen konzentrieren.

Umgang mit verwaisten Referenzen

Manchmal können Referenzen veraltet werden, wenn Eltern-Dokumente gelöscht werden. Lassen Sie uns demonstrieren, wie man damit umgeht:

Erstellen eines Test-Autors und eines Test-Buchs

db.authors.insertOne({
    _id: ObjectId("author3"),
    name: "Mark Twain",
    nationality: "American",
    birthYear: 1835
})

db.books.insertOne({
    title: "The Adventures of Tom Sawyer",
    author_id: ObjectId("author3"),
    published: 1876,
    genre: "Classic Literature"
})

Simulieren der Referenzbereinigung

Löschen Sie einen Autor und überprüfen Sie auf verwaiste Bücher:

db.authors.deleteOne({ _id: ObjectId("author3") })

## Finden Sie Bücher mit nicht existierenden Autorreferenzen
db.books.find({
    author_id: { $nin: db.authors.distinct("_id") }
})

Implementieren der Referenzverwaltung

Erstellen Sie eine Funktion, um verwaiste Referenzen zu bereinigen:

db.books.deleteMany({
    author_id: { $nin: db.authors.distinct("_id") }
})

Vermeiden ungültiger Referenzen

Verwenden Sie Validierungsregeln beim Einfügen von Dokumenten:

db.createCollection("books", {
   validator: {
      $jsonSchema: {
         bsonType: "object",
         required: ["title", "author_id"],
         properties: {
            title: {
               bsonType: "string",
               description: "muss ein String sein und ist erforderlich"
            },
            author_id: {
               bsonType: "objectId",
               description: "muss eine gültige Autorreferenz sein"
            }
         }
      }
   }
})

Indexieren von Referenzen für die Leistung

Erstellen Sie einen Index auf das Referenzfeld:

db.books.createIndex({ author_id: 1 })

Überprüfen der Indexerstellung

db.books.getIndexes()

Beispielausgabe

[
  { v: 2, key: { _id: 1 }, name: '_id_' },
  { v: 2, key: { author_id: 1 }, name: 'author_id_1' }
]

Bewährte Praktiken bei der Referenzverwaltung

1. Validieren Sie immer Referenzen vor dem Einfügen
2. Verwenden Sie Indexe auf Referenzfeldern
3. Implementieren Sie Bereinigungsmechanismen
4. Überlegen Sie die Verwendung von Datenbanktransaktionen für komplexe Vorgänge

Demonstration der Referenzvalidierung

## Dies wird fehlschlagen, da die author_id ungültig ist
db.books.insertOne({
    title: "Invalid Book",
    author_id: ObjectId("invalid_id")
})

Zusammenfassung

In diesem Lab haben wir gelernt, wie man in MongoDB Datenbeziehungen mit Hilfe von Dokumentreferenzen entwirft. Wir haben ein praktisches Beispiel eines Bibliothekssystems erstellt, in dem Bücher und Autoren modelliert wurden. Wir haben die zwei Hauptweisen untersucht, Beziehungen in MongoDB zu erstellen: eingebettete Dokumente und Dokumentreferenzen. Für unser Bibliothekssystem haben wir entschieden, Dokumentreferenzen zu verwenden, um verwandte Daten zwischen Sammlungen zu verknüpfen. Wir haben die wichtigsten Grundsätze von Dokumentreferenzen gelernt, wie das Verwenden von _id zum Erstellen von Verknüpfungen, das Halten von Referenzen einfach und konsistent und das Auswählen von Referenzen, wenn die Daten groß sind oder häufig geändert werden. Wir haben auch unsere Bibliotheksdatenbank erweitert, indem wir komplexere Beziehungen zwischen Eltern- und Kinddokumenten erstellt haben.