MongoDB Arrays handhaben

MongoDBBeginner
Jetzt üben

Einführung

In diesem Lab lernen Sie, wie Sie mit MongoDB-Arrays umgehen. Arrays sind eine grundlegende Datenstruktur in MongoDB, die es Ihnen ermöglicht, Listen von Werten innerhalb eines einzelnen Dokuments zu speichern. Sie werden verschiedene Operationen untersuchen, darunter das Erstellen von Dokumenten mit Array-Feldern, das Hinzufügen und Entfernen von Elementen, das Aktualisieren von Werten innerhalb von Arrays und das Ausführen von Abfragen basierend auf Array-Inhalten. Diese Fähigkeiten sind unerlässlich für die effektive Verwaltung komplexer Datenstrukturen in MongoDB.

Am Ende dieses Labs werden Sie ein solides, praktisches Verständnis dafür haben, wie man mit MongoDB-Arrays arbeitet, was Ihnen ermöglicht, anspruchsvollere und flexiblere Datenbankschemata zu erstellen.

Dokumente mit Array-Feldern erstellen

In diesem ersten Schritt verbinden Sie sich mit dem MongoDB-Server und erstellen ein neues Dokument, das ein Array-Feld enthält. Arrays sind leistungsfähig, da sie es Ihnen ermöglichen, mehrere zusammengehörige Werte wie Tags, Kommentare oder Kurse direkt in einem Dokument zu speichern.

Öffnen Sie zunächst die MongoDB-Shell, um mit Ihrer Datenbank zu interagieren. Alle nachfolgenden Operationen in diesem Lab werden Sie innerhalb der mongosh-Shell durchführen.

mongosh

Sobald Sie sich in der Shell befinden, sehen Sie eine Eingabeaufforderung wie test>. Wechseln wir zur Datenbank arraylab, die für dieses Lab vorkonfiguriert wurde.

use arraylab

Das setup-Skript hat bereits eine students-Collection erstellt und ein Dokument eingefügt. Nun fügen Sie ein neues Dokument für eine Studentin namens "Alice Johnson" ein. Dieses Dokument wird ein courses-Feld haben, das ein Array von Strings ist.

db.students.insertOne({
    name: "Alice Johnson",
    age: 22,
    courses: ["Mathematics", "Computer Science", "Physics"]
})

Dieser Befehl fügt ein einzelnes Dokument in die students-Collection ein. Das Feld courses enthält ein Array mit drei String-Elementen.

Um zu bestätigen, dass das Dokument erfolgreich erstellt wurde, können Sie die find()-Methode verwenden, um alle Dokumente in der Collection abzurufen. Die Methode .pretty() formatiert die Ausgabe lesbarer.

db.students.find().pretty()

Sie sollten zwei Dokumente sehen: das für "Bob Smith", das während des Setups erstellt wurde, und das von Ihnen gerade hinzugefügte Dokument für "Alice Johnson".

[
  {
    _id: ObjectId("..."),
    name: 'Bob Smith',
    grades: [ 95, 87, 92 ],
    activities: [ 'Chess Club', 'Debate Team' ]
  },
  {
    _id: ObjectId("..."),
    name: 'Alice Johnson',
    age: 22,
    courses: [ 'Mathematics', 'Computer Science', 'Physics' ]
  }
]

Elemente zu einem Array hinzufügen

Nachdem Arrays erstellt wurden, ist eine häufige Aufgabe, neue Elemente hinzuzufügen. In diesem Schritt lernen Sie, wie Sie den $push-Operator verwenden, um Elemente an ein bestehendes Array anzuhängen.

Um ein einzelnes Element zu einem Array hinzuzufügen, verwenden Sie den $push-Operator in einer Update-Operation. Fügen wir Alice Johnsons Kursliste einen neuen Kurs hinzu: "Data Science".

db.students.updateOne(
    { name: "Alice Johnson" },
    { $push: { courses: "Data Science" } }
)

In diesem Befehl ist das erste Argument { name: "Alice Johnson" } der Filter, der das zu aktualisierende Dokument findet. Das zweite Argument { $push: { courses: "Data Science" } } gibt die Update-Aktion an. $push hängt den Wert "Data Science" an das courses-Array an.

Überprüfen wir die Änderung, indem wir Alices Dokument erneut abrufen.

db.students.find({ name: "Alice Johnson" }).pretty()

Die Ausgabe zeigt den neuen Kurs, der dem Array hinzugefügt wurde.

[
  {
    _id: ObjectId("..."),
    name: 'Alice Johnson',
    age: 22,
    courses: [ 'Mathematics', 'Computer Science', 'Physics', 'Data Science' ]
  }
]

Um mehrere Elemente gleichzeitig hinzuzufügen, können Sie $push mit dem $each-Modifikator kombinieren. Fügen wir Bob Smith zwei neue Aktivitäten hinzu.

db.students.updateOne(
    { name: "Bob Smith" },
    { $push: { activities: { $each: ["Robotics Club", "Swimming Team"] } } }
)

Hier teilt $each $push mit, jedes Element aus der bereitgestellten Liste (["Robotics Club", "Swimming Team"]) an das activities-Array anzuhängen.

Überprüfen Sie auch dieses Update:

db.students.find({ name: "Bob Smith" }).pretty()

Die Ausgabe bestätigt, dass beide neuen Aktivitäten hinzugefügt wurden.

[
  {
    _id: ObjectId("..."),
    name: 'Bob Smith',
    grades: [ 95, 87, 92 ],
    activities: [ 'Chess Club', 'Debate Team', 'Robotics Club', 'Swimming Team' ]
  }
]

Elemente aus einem Array entfernen

So wie Sie Elemente hinzufügen können, müssen Sie sie auch entfernen können. MongoDB bietet hierfür mehrere Operatoren. In diesem Schritt lernen Sie, wie Sie mit $pull Elemente nach Wert und mit $pop Elemente nach Position entfernen.

Um ein bestimmtes Element anhand seines Werts aus einem Array zu entfernen, verwenden Sie den $pull-Operator. Entfernen wir "Physics" aus Alices Kursliste.

db.students.updateOne(
    { name: "Alice Johnson" },
    { $pull: { courses: "Physics" } }
)

Dieser Befehl findet das Dokument für Alice und entfernt alle Vorkommen von "Physics" aus ihrem courses-Array. Überprüfen Sie das Ergebnis:

db.students.find({ name: "Alice Johnson" }).pretty()

Die Ausgabe zeigt, dass "Physics" nicht mehr im Array enthalten ist.

[
  {
    _id: ObjectId("..."),
    name: 'Alice Johnson',
    age: 22,
    courses: [ 'Mathematics', 'Computer Science', 'Data Science' ]
  }
]

Um mehrere Elemente zu entfernen, die mit Werten in einer Liste übereinstimmen, können Sie den $pullAll-Operator verwenden. Entfernen wir sowohl "Chess Club" als auch "Debate Team" aus Bobs Aktivitäten.

db.students.updateOne(
    { name: "Bob Smith" },
    { $pullAll: { activities: ["Chess Club", "Debate Team"] } }
)

Überprüfen Sie das Update für Bobs Dokument:

db.students.find({ name: "Bob Smith" }).pretty()

Die Ausgabe bestätigt die Entfernung der angegebenen Aktivitäten.

[
  {
    _id: ObjectId("..."),
    name: 'Bob Smith',
    grades: [ 95, 87, 92 ],
    activities: [ 'Robotics Club', 'Swimming Team' ]
  }
]

Wenn Sie ein Element vom Anfang oder Ende eines Arrays entfernen müssen, können Sie den $pop-Operator verwenden. Verwenden Sie 1, um das letzte Element zu entfernen, und -1, um das erste zu entfernen. Entfernen wir den letzten Kurs aus Alices Liste.

db.students.updateOne(
    { name: "Alice Johnson" },
    { $pop: { courses: 1 } }
)

Sehen wir uns den Endzustand von Alices Kursen an:

db.students.find({ name: "Alice Johnson" }).pretty()

Die Ausgabe zeigt, dass das letzte Element, "Data Science", entfernt wurde.

[
  {
    _id: ObjectId("..."),
    name: 'Alice Johnson',
    age: 22,
    courses: [ 'Mathematics', 'Computer Science' ]
  }
]

Elemente in einem Array aktualisieren

Das Aktualisieren bestehender Elemente innerhalb eines Arrays ist eine weitere wichtige Operation. Dieser Schritt behandelt, wie Array-Elemente mithilfe von Positionsoperatoren aktualisiert werden.

Um ein einzelnes, spezifisches Element in einem Array zu aktualisieren, müssen Sie zuerst das Dokument und das zu ändernde Element abgleichen. Anschließend können Sie den Positionsoperator $ verwenden, um die Aktualisierung durchzuführen. Ändern wir "Mathematics" in "Advanced Mathematics" in Alices courses-Array.

db.students.updateOne(
    { name: "Alice Johnson", courses: "Mathematics" },
    { $set: { "courses.$": "Advanced Mathematics" } }
)

In diesem Befehl findet der Filter { name: "Alice Johnson", courses: "Mathematics" } das Dokument und identifiziert die Position des ersten Vorkommens von "Mathematics" im Array. Das Update { $set: { "courses.$": "Advanced Mathematics" } } verwendet courses.$, um sich auf die Position dieses übereinstimmenden Elements zu beziehen und dessen neuen Wert festzulegen.

Überprüfen Sie die Änderung:

db.students.find({ name: "Alice Johnson" }).pretty()

Die Ausgabe zeigt den aktualisierten Kursnamen.

[
  {
    _id: ObjectId("..."),
    name: 'Alice Johnson',
    age: 22,
    courses: [ 'Advanced Mathematics', 'Computer Science' ]
  }
]

Um alle Elemente in einem Array zu aktualisieren, die einer Bedingung entsprechen, können Sie den All-Positionsoperator $[ ] verwenden. Erhöhen wir alle Noten von Bob um 5 Punkte mit dem $inc (increment)-Operator.

db.students.updateOne(
    { name: "Bob Smith" },
    { $inc: { "grades.$[]": 5 } }
)

Hier wendet grades.$[] die $inc-Operation auf jedes Element im grades-Array an.

Überprüfen Sie Bobs neue Noten:

db.students.find({ name: "Bob Smith" }).pretty()

Die Ausgabe zeigt, dass jede Note um 5 erhöht wurde.

[
  {
    _id: ObjectId("..."),
    name: 'Bob Smith',
    grades: [ 100, 92, 97 ],
    activities: [ 'Robotics Club', 'Swimming Team' ]
  }
]

Dokumente basierend auf Array-Inhalt abfragen

Abfragen sind das Herzstück jeder Datenbank. MongoDB bietet eine reichhaltige Auswahl an Operatoren, um Dokumente basierend auf dem Inhalt ihrer Arrays abzufragen. In diesem letzten Schritt lernen Sie, wie Sie Dokumente finden, indem Sie Array-Elemente und deren Eigenschaften abgleichen.

Um alle Dokumente zu finden, in denen ein Array ein bestimmtes Element enthält, können Sie diesen Wert in Ihren Abfragefilter aufnehmen. Suchen wir alle Studenten, die in "Computer Science" eingeschrieben sind.

db.students.find({ courses: "Computer Science" }).pretty()

Diese Abfrage gibt Alices Dokument zurück, da ihr courses-Array "Computer Science" enthält.

Um Dokumente zu finden, in denen ein Array alle Elemente einer bestimmten Menge enthält, verwenden Sie den $all-Operator.

db.students.find({
    courses: { $all: ["Advanced Mathematics", "Computer Science"] }
}).pretty()

Dies gibt ebenfalls Alices Dokument zurück, da ihr courses-Array beide Werte enthält.

Für komplexere Bedingungen bei Array-Elementen ist der $elemMatch-Operator sehr nützlich. Er ermöglicht es Ihnen, mehrere Kriterien anzugeben, die ein einzelnes Array-Element erfüllen muss. Suchen wir Studenten, die mindestens eine Note von über 95 haben.

db.students.find({
    grades: { $elemMatch: { $gt: 95 } }
}).pretty()

Diese Abfrage gibt Bobs Dokument zurück, da er Noten hat, die jetzt über 95 liegen. $gt steht für "größer als" (greater than).

Sie können auch basierend auf der Anzahl der Elemente in einem Array mit dem $size-Operator abfragen. Suchen wir Studenten, die in genau zwei Aktivitäten sind.

db.students.find({
    activities: { $size: 2 }
}).pretty()

Dies gibt Bobs Dokument zurück, da sein activities-Array derzeit zwei Elemente enthält.

Zum Schluss fügen wir einen weiteren Studenten hinzu, um eine kombinierte Abfrage zu üben.

db.students.insertOne({
    name: "Charlie Brown",
    courses: ["Art", "Music", "Literature"],
    grades: [88, 92, 85],
    activities: ["Painting Club"]
})

Suchen Sie nun Studenten, die entweder "Art" oder "Music" belegen (mit dem $in-Operator) UND mindestens eine Note von 90 oder höher haben (mit $elemMatch und $gte).

db.students.find({
    courses: { $in: ["Art", "Music"] },
    grades: { $elemMatch: { $gte: 90 } }
}).pretty()

Diese Abfrage gibt das Dokument für "Charlie Brown" zurück, der beide Bedingungen erfüllt.

Zusammenfassung

In diesem Lab haben Sie die grundlegenden Techniken für die Handhabung von Arrays in MongoDB gelernt. Sie haben mit der Erstellung von Dokumenten mit Array-Feldern begonnen und dann das Hinzufügen von Elementen mit $push und $each geübt. Sie haben das Entfernen von Elementen nach Wert mit $pull und $pullAll und nach Position mit $pop untersucht. Sie haben auch gelernt, wie spezifische Array-Elemente mit dem Positionsoperator $ und alle Elemente mit dem $[ ]-Operator aktualisiert werden. Schließlich haben Sie geübt, Dokumente basierend auf Array-Inhalten mit Operatoren wie $all, $elemMatch, $size und $in abzufragen. Diese Fähigkeiten sind entscheidend für die Erstellung und Verwaltung von Anwendungen mit komplexen, verschachtelten Datenstrukturen in MongoDB.