MongoDB-Sammlungen filtern

Einführung

In diesem Lab werden Sie lernen, wie Sie MongoDB-Sammlungen effektiv mithilfe verschiedener Abfrageverfahren filtern. Im Lab werden die Anwendung mehrerer Bedingungen, das Verwenden von Vergleichsoperatoren, das Finden von regulären Ausdrücken, das Überprüfen der Feldexistenz und das Finden von NULL-Werten behandelt. Diese Fähigkeiten sind essentiell für das Abfragen und Verarbeiten von Daten in MongoDB und ermöglichen es Ihnen, präzise und relevante Informationen aus Ihrer Datenbank zu extrahieren. Die schrittweisen Anweisungen enthalten praktische Beispiele und Erklärungen, um Ihnen die Grundlagen des MongoDB-Abfragens zu vermitteln.

Skills Graph

Mehrere Bedingungen anwenden

In diesem Schritt lernen Sie, wie Sie mehrere Bedingungen bei der Abfrage von MongoDB-Sammlungen anwenden. Mit mehreren Bedingungen können Sie präzisere und komplexere Abfragen erstellen, um Ihre Daten effektiv zu filtern.

Öffnen Sie zunächst ein Terminal und starten Sie die MongoDB-Shell:

mongosh

Erstellen wir nun eine Beispielsammlung von Schülern, um Mehrbedingungenabfragen zu demonstrieren:

use school_database

db.students.insertMany([
    { name: "Alice", age: 22, grade: "A", major: "Computer Science" },
    { name: "Bob", age: 20, grade: "B", major: "Mathematics" },
    { name: "Charlie", age: 25, grade: "A", major: "Physics" },
    { name: "David", age: 19, grade: "C", major: "Computer Science" }
])

Untersuchen wir, wie wir mehrere Bedingungen mit dem $and-Operator anwenden können. Dies ermöglicht es uns, mehrere Bedingungen anzugeben, die alle zutreffen müssen:

db.students.find({
  $and: [{ age: { $gte: 20 } }, { grade: "A" }]
});

Diese Abfrage wird Schülern zurückgeben, die 20 Jahre oder älter sind UND eine Note von „A“ haben. Zergliedern wir die Bedingungen:

• $gte bedeutet „größer als oder gleich“
• $and stellt sicher, dass beide Bedingungen erfüllt sein müssen

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

[
  {
    _id: ObjectId("..."),
    name: 'Alice',
    age: 22,
    grade: 'A',
    major: 'Computer Science'
  },
  {
    _id: ObjectId("..."),
    name: 'Charlie',
    age: 25,
    grade: 'A',
    major: 'Physics'
  }
]

Wir können auch den $or-Operator verwenden, um Dokumente zu finden, die mindestens eine Bedingung erfüllen:

db.students.find({
  $or: [{ major: "Computer Science" }, { age: { $lt: 21 } }]
});

Diese Abfrage wird Schülern zurückgeben, die entweder Informatik studieren ODER jünger als 21 Jahre sind.

• $lt bedeutet „kleiner als“

Das Ergebnis wird Schülern wie David (unter 21) und Alice und David (Informatikstudenten) enthalten.

Vergleichsoperatoren verwenden

In diesem Schritt lernen Sie über die Vergleichsoperatoren von MongoDB, die Ihnen helfen, komplexere Abfragen zu erstellen, um Daten basierend auf verschiedenen Bedingungen zu filtern.

Stellen Sie zunächst sicher, dass Sie in der MongoDB-Shell sind:

mongosh

Fahren wir mit der Verwendung der school_database aus dem vorherigen Schritt fort. Wenn Sie die Shell geschlossen haben, erstellen Sie die Schülersammlung erneut:

use school_database

db.students.insertMany([
    { name: "Alice", age: 22, grade: "A", major: "Computer Science", credits: 45 },
    { name: "Bob", age: 20, grade: "B", major: "Mathematics", credits: 35 },
    { name: "Charlie", age: 25, grade: "A", major: "Physics", credits: 50 },
    { name: "David", age: 19, grade: "C", major: "Computer Science", credits: 25 }
])

MongoDB bietet leistungsstarke Vergleichsoperatoren, um Ihnen dabei zu helfen, Daten präzise zu filtern. Betrachten wir einige wichtige Operatoren:

1. Größer als ($gt) und Kleiner als ($lt):

db.students.find({ age: { $gt: 20, $lt: 25 } });

Diese Abfrage findet Schülern, die älter als 20 Jahre, aber jünger als 25 Jahre sind. In unserem Beispiel würde dies Alice zurückgeben.

2. Größer als oder gleich ($gte) und Kleiner als oder gleich ($lte):

db.students.find({ credits: { $gte: 40, $lte: 50 } });

Dies findet Schülern mit 40 bis 50 Credits (inklusive). Dies wird Alice und Charlie zurückgeben.

3. Nicht gleich ($ne):

db.students.find({ grade: { $ne: "C" } });

Dies gibt Schülern zurück, deren Note nicht „C“ ist, was Alice, Bob und Charlie sein würde.

Zergliedern wir diese Operatoren:

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

Jede Abfrage zeigt eine andere Möglichkeit, um Daten präzise mit Vergleichsoperatoren zu filtern.

Reguläre Ausdrücke abgleichen

In diesem Schritt lernen Sie, wie Sie in MongoDB reguläre Ausdrücke (RegEx) verwenden, um flexible und leistungsstarke Textsuchen in Ihren Sammlungen durchzuführen.

Stellen Sie zunächst sicher, dass Sie in der MongoDB-Shell sind:

mongosh

Fahren wir mit der Verwendung der school_database fort und fügen Sie einige weitere vielfältige Daten hinzu:

use school_database

db.students.insertMany([
    { name: "Alice Johnson", age: 22, major: "Computer Science", email: "[email protected]" },
    { name: "Bob Smith", age: 20, major: "Mathematics", email: "[email protected]" },
    { name: "Charlie Brown", age: 25, major: "Physics", email: "[email protected]" },
    { name: "David Lee", age: 19, major: "Computer Engineering", email: "[email protected]" }
])

Reguläre Ausdrücke in MongoDB ermöglichen Ihnen komplexe Textsuchen. Betrachten wir verschiedene RegEx-Muster:

1. Namen finden, die mit einem bestimmten Buchstaben beginnen:

db.students.find({ name: { $regex: "^A" } });

Diese Abfrage findet Schülern, deren Namen mit "A" beginnen. Das Symbol ^ bedeutet "beginnt mit".

2. E-Mails von einem bestimmten Domänen finden:

db.students.find({ email: { $regex: "@example.com$" } });

Diese Abfrage findet Schülern mit E-Mail-Adressen, die mit "@example.com" enden. Das Symbol $ bedeutet "endet mit".

3. Groß-/Kleinschreibung-unabhängiges RegEx-Suchen:

db.students.find({ name: { $regex: "johnson", $options: "i" } });

Dies findet Namen, die "johnson" enthalten, unabhängig von der Groß-/Kleinschreibung. Die Option $options: "i" macht die Suche groß-/kleinschreibungslos.

4. Teilmatch:

db.students.find({ major: { $regex: "Computer" } });

Dies findet Schülern, bei denen "Computer" irgendwo in ihrem Studiengang vorkommt.

RegEx-Muster bieten leistungsstarke Möglichkeiten, um Daten zu durchsuchen und zu filtern:

• ^: Beginnt mit
• $: Endet mit
• $options: "i": Groß-/Kleinschreibungslose Übereinstimmung
• Teilmatch erfordert keine besonderen Symbole

Feldexistenz überprüfen

In diesem Schritt lernen Sie, wie Sie die Existenz von Feldern in MongoDB-Dokumenten mithilfe leistungsstarker Operatoren überprüfen, die Ihnen helfen, Sammlungen basierend auf der Feldpräsenz zu filtern.

Stellen Sie zunächst sicher, dass Sie in der MongoDB-Shell sind:

mongosh

Erstellen wir eine Sammlung mit Dokumenten unterschiedlicher Strukturen, um die Überprüfung der Feldexistenz zu demonstrieren:

use school_database

db.students.insertMany([
    { name: "Alice Johnson", age: 22, major: "Computer Science", scholarship: 1000 },
    { name: "Bob Smith", age: 20, major: "Mathematics" },
    { name: "Charlie Brown", age: 25, major: "Physics", internship: "Research Lab" },
    { name: "David Lee", age: 19, contact: { phone: "555-1234" } }
])

MongoDB bietet den $exists-Operator an, um die Feldpräsenz zu überprüfen:

1. Dokumente mit einem bestimmten Feld finden:

db.students.find({ scholarship: { $exists: true } });

Diese Abfrage gibt Schülern zurück, die ein Stipendiumsfeld haben. In unserem Beispiel wird dies Alice's Dokument zurückgeben.

2. Dokumente ohne ein bestimmtes Feld finden:

db.students.find({ internship: { $exists: false } });

Diese Abfrage gibt Schülern zurück, die kein Praktikumsfeld haben, was Alice, Bob und David einschließt.

3. $exists mit Überprüfungen von geschachtelten Feldern kombinieren:

db.students.find({
  contact: { $exists: true },
  "contact.phone": { $exists: true }
});

Dies findet Dokumente mit einem Kontaktfeld, das auch ein Telefon-Unterfeld hat, was Davids Dokument entspricht.

Wichtige Punkte zur Feldexistenz:

• $exists: true überprüft, ob ein Feld vorhanden ist
• $exists: false überprüft, ob ein Feld fehlt
• Sie können komplexe Abfragen erstellen, um die Existenz geschachtelter Felder zu überprüfen

Leere Werte finden

In diesem Schritt lernen Sie, wie Sie in MongoDB leere Werte finden und mit ihnen umgehen, und verstehen die Unterschiede zwischen null, undefined und fehlenden Feldern.

Stellen Sie zunächst sicher, dass Sie in der MongoDB-Shell sind:

mongosh

Erstellen wir eine Sammlung mit Dokumenten, die null- und undefined-Werte enthalten:

use school_database

db.students.insertMany([
    { name: "Alice Johnson", age: 22, email: null },
    { name: "Bob Smith", age: null, major: "Mathematics" },
    { name: "Charlie Brown", age: 25, phone: undefined },
    { name: "David Lee", contact: { email: null } }
])

MongoDB bietet spezifische Möglichkeiten, um null- und undefined-Werte abzufragen:

1. Dokumente mit null-Werten finden:

db.students.find({ email: null });

Diese Abfrage gibt Dokumente zurück, bei denen das email-Feld explizit auf null gesetzt ist. In unserem Beispiel wird dies Alice's Dokument zurückgeben.

2. Dokumente mit null-Feldern finden:

db.students.find({ age: null });

Dies findet Dokumente, bei denen das age-Feld speziell null ist. Dies wird Bob's Dokument zurückgeben.

3. Prüfen auf null in geschachtelten Dokumenten:

db.students.find({ "contact.email": null });

Dies findet Dokumente mit null-E-Mail in einem geschachtelten Kontakt-Objekt, was Davids Dokument entspricht.

4. Unterscheiden zwischen null und fehlenden Feldern:

db.students.find({
  $and: [{ phone: null }, { phone: { $exists: true } }]
});

Diese Abfrage findet Dokumente, bei denen das phone-Feld existiert und null ist. In unserem Beispiel wird keine Dokumente zurückgegeben.

Wichtige Punkte zu null-Werten:

• null repräsentiert eine bewusste Abwesenheit eines Objektwerts
• Anders als undefined, was bedeutet, dass eine Variable noch nicht zugewiesen wurde
• Verwenden Sie $exists, um die Feldpräsenz zu überprüfen
• Vorsicht bei geschachtelten Dokumentabfragen

Zusammenfassung

In diesem Lab haben Sie gelernt, wie Sie mehrere Bedingungen anwenden, wenn Sie MongoDB-Sammlungen abfragen, indem Sie die Operatoren $and und $or verwenden. Dies ermöglicht es Ihnen, präzisere und komplexere Abfragen zu erstellen, um Ihre Daten effektiv zu filtern. Sie haben auch verschiedene Vergleichsoperatoren wie $gte (größer als oder gleich) und $lt (kleiner als) untersucht, um Ihre Suchkriterien zu verfeinern. Darüber hinaus haben Sie entdeckt, wie Sie reguläre Ausdrücke abgleichen, die Existenz von Feldern überprüfen und leere Werte in Ihren MongoDB-Sammlungen finden, was Ihnen leistungsstarke Werkzeuge zur effektiven Filterung und Abrufung der benötigten Daten bietet.