MongoDB Collections filtern

Einführung

In diesem Lab lernen Sie, wie Sie MongoDB-Collections mithilfe verschiedener Abfragetechniken effektiv filtern. Das Lab behandelt die Anwendung mehrerer Bedingungen, die Verwendung von Vergleichsoperatoren, das Abgleichen mit regulären Ausdrücken, die Überprüfung der Feldexistenz und das Finden von Nullwerten. Diese Fähigkeiten sind für die präzise Datenabfrage in MongoDB unerlässlich. Die Schritt-für-Schritt-Anleitungen bieten praktische Beispiele, die Ihnen helfen, die Grundlagen von MongoDB-Abfragen zu meistern.

Mehrere Bedingungen anwenden

In diesem Schritt lernen Sie, wie Sie mehrere Bedingungen anwenden, um Dokumente in einer MongoDB-Collection zu filtern. Dies ermöglicht präzisere Abfragen durch die Kombination mehrerer Kriterien.

Öffnen Sie zunächst Ihr Terminal und starten Sie die MongoDB Shell. Diese interaktive Shell ist der Ort, an dem Sie alle Ihre Datenbankbefehle ausführen werden.

mongosh

Sobald Sie sich in der mongosh-Shell befinden, sehen Sie eine > Eingabeaufforderung. Wechseln wir zu einer neuen Datenbank namens school_database und erstellen eine students-Collection mit einigen Beispieldaten.

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" }
]);

Dieser Befehl fügt vier Dokumente in die students-Collection ein. Nun suchen wir nach Studenten, die mehrere Bedingungen erfüllen. Wir verwenden den $and-Operator, um Studenten zu finden, die 20 Jahre oder älter sind UND die Note "A" haben.

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

Diese Abfrage verwendet $gte (größer als oder gleich) und $and, um sicherzustellen, dass beide Bedingungen erfüllt sind. Die Ausgabe zeigt Alice und Charlie:

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

Als Nächstes verwenden wir den $or-Operator, um Dokumente zu finden, die mindestens eine von mehreren Bedingungen erfüllen. Diese Abfrage findet Studenten, die entweder "Computer Science" studieren ODER jünger als 21 Jahre sind.

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

Diese Abfrage verwendet $lt (kleiner als). Das Ergebnis umfasst Alice und David (Computer Science-Studenten) sowie Bob und David (unter 21). Da David beide Bedingungen erfüllt, wird er einmal angezeigt.

[
  {
    _id: ObjectId("..."),
    name: 'Alice',
    age: 22,
    grade: 'A',
    major: 'Computer Science'
  },
  {
    _id: ObjectId("..."),
    name: 'Bob',
    age: 20,
    grade: 'B',
    major: 'Mathematics'
  },
  {
    _id: ObjectId("..."),
    name: 'David',
    age: 19,
    grade: 'C',
    major: 'Computer Science'
  }
]

Im nächsten Schritt werden Sie weitere Vergleichsoperatoren untersuchen. Vorerst können Sie in der mongosh-Shell bleiben.

Vergleichsoperatoren verwenden

In diesem Schritt verwenden Sie die Vergleichsoperatoren von MongoDB, um anspruchsvollere Abfragen zu erstellen. Diese Operatoren ermöglichen es Ihnen, Daten basierend auf Wertvergleichen zu filtern.

Sie sollten sich immer noch in der mongosh-Shell aus dem vorherigen Schritt befinden. Zuerst löschen wir die vorhandene Collection und fügen neue Daten mit einem credits-Feld hinzu, mit dem wir arbeiten können.

db.students.drop();

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 }
]);

Nun verwenden wir die Operatoren "größer als" ($gt) und "kleiner als" ($lt), um Studenten zu finden, die älter als 20, aber jünger als 25 Jahre sind.

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

Diese Abfrage gibt nur das Dokument für Alice zurück, die 22 Jahre alt ist.

Verwenden Sie als Nächstes "größer als oder gleich" ($gte) und "kleiner als oder gleich" ($lte), um Studenten mit Credits zwischen 40 und 50 (einschließlich) zu finden.

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

Diese Abfrage gibt Alice (45 Credits) und Charlie (50 Credits) zurück.

Schließlich verwenden wir den Operator "ungleich" ($ne), um alle Studenten zu finden, deren Note nicht "C" ist.

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

Dies gibt Alice, Bob und Charlie zurück und schließt David aus, der die Note "C" hat. Diese Operatoren sind grundlegend für die Erstellung detaillierter und spezifischer Abfragen in MongoDB.

Mit regulären Ausdrücken abgleichen

Reguläre Ausdrücke (Regex) bieten eine flexible Möglichkeit, leistungsstarke Textsuchvorgänge durchzuführen. In diesem Schritt lernen Sie, wie Sie Regex in Ihren MongoDB-Abfragen verwenden.

Bereiten wir zunächst die Daten für diesen Schritt vor. Löschen Sie die Collection und fügen Sie neue Dokumente mit detaillierteren String-Feldern ein.

db.students.drop();

db.students.insertMany([
  {
    name: "Alice Johnson",
    age: 22,
    major: "Computer Science",
    email: "alice.j@example.com"
  },
  {
    name: "Bob Smith",
    age: 20,
    major: "Mathematics",
    email: "bob.smith@university.edu"
  },
  {
    name: "Charlie Brown",
    age: 25,
    major: "Physics",
    email: "charlie.brown@school.org"
  },
  {
    name: "David Lee",
    age: 19,
    major: "Computer Engineering",
    email: "david.lee@tech.net"
  }
]);

Um alle Studenten zu finden, deren Namen mit "Alice" beginnen, können Sie den $regex-Operator mit dem ^-Anker verwenden.

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

Diese Abfrage gibt das Dokument für "Alice Johnson" zurück. Das Zeichen ^ kennzeichnet den Anfang des Strings.

Um Studenten mit einer E-Mail-Adresse einer bestimmten Domain, wie z. B. example.com, zu finden, verwenden Sie den $-Anker, um das Ende des Strings abzugleichen.

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

Dies findet "Alice Johnson", deren E-Mail mit @example.com endet.

Sie können auch Groß- und Kleinschreibung ignorierende Suchen durchführen. Die folgende Abfrage findet jeden Studenten mit "smith" im Namen, unabhängig von der Groß-/Kleinschreibung, indem sie die Option i verwendet.

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

Diese Abfrage stimmt mit "Bob Smith" überein.

Schließlich können Sie, um jeden Studiengang zu finden, der das Wort "Computer" enthält, ein einfaches Regex-Muster ohne Anker verwenden.

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

Dies gibt sowohl "Alice Johnson" (Computer Science) als auch "David Lee" (Computer Engineering) zurück.

Auf Feldpräsenz prüfen

Manchmal haben Dokumente in einer Collection unterschiedliche Strukturen. In diesem Schritt lernen Sie, wie Sie Dokumente basierend darauf abfragen, ob ein bestimmtes Feld vorhanden ist oder nicht.

Beginnen wir mit dem Einfügen einer neuen Reihe von Dokumenten, bei denen einige Felder fehlen.

db.students.drop();

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

Um alle Studenten zu finden, die ein scholarship-Feld haben, verwenden Sie den $exists-Operator mit dem Wert true.

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

Diese Abfrage gibt nur das Dokument für Alice zurück, da sie die einzige ist, die das scholarship-Feld besitzt.

Umgekehrt, um Studenten zu finden, die kein internship-Feld haben, setzen Sie $exists auf false.

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

Dies gibt die Dokumente für Alice, Bob und David zurück, da keiner von ihnen das internship-Feld hat.

Der $exists-Operator funktioniert auch bei verschachtelten Feldern. Um einen Studenten zu finden, der ein contact-Objekt hat, das ein phone-Feld enthält, können Sie die Punktnotation verwenden.

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

Diese Abfrage sucht speziell nach dem phone-Feld innerhalb des contact-Objekts und gibt das Dokument für David zurück.

Null-Werte finden

In diesem letzten Schritt lernen Sie, wie Sie Dokumente abfragen, die null-Werte enthalten. Ein null-Wert repräsentiert die absichtliche Abwesenheit eines Wertes.

Zuerst richten wir eine Collection mit Dokumenten ein, die null-Werte und fehlende Felder enthalten.

db.students.drop();

db.students.insertMany([
  { name: "Alice", age: 22, email: null },
  { name: "Bob", age: 20, major: "Mathematics" },
  { name: "Charlie", age: null, major: "Physics" },
  { name: "David", contact: { email: null } }
]);

Um Dokumente zu finden, bei denen ein Feld einen null-Wert hat, können Sie direkt nach null abfragen. Die folgende Abfrage findet alle Dokumente, bei denen das Feld email null ist ODER das Feld email nicht existiert.

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

Diese Abfrage gibt alle vier Dokumente zurück: Alice (bei der email explizit null ist), Bob (bei dem das Feld email fehlt), Charlie (bei dem das Feld email fehlt) und David (bei dem das Feld email fehlt).

Um nur die Dokumente zu finden, bei denen ein Feld explizit auf null gesetzt ist, müssen Sie die null-Prüfung mit einer $exists-Prüfung kombinieren.

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

Alternativ können Sie den $type-Operator verwenden. Der BSON-Typ für null ist 10. Diese Abfrage gibt nur das Dokument für Alice zurück.

db.students.find({ email: { $type: 10 } });

Sie können auch nach null-Werten in verschachtelten Dokumenten abfragen. Die folgende Abfrage findet Dokumente, bei denen das Feld email im contact-Objekt null ist ODER bei denen das Feld contact nicht existiert.

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

Dies gibt alle vier Dokumente zurück: Alice, Bob und Charlie (bei denen das Feld contact fehlt) und David (bei dem contact.email explizit null ist). Das Verständnis, wie man nach null abfragt, ist entscheidend für die Handhabung unvollständiger oder spärlicher Daten.

Wenn Sie fertig sind, können Sie die mongosh-Shell verlassen, indem Sie exit eingeben oder Strg+D drücken.

Zusammenfassung

In diesem Lab haben Sie mehrere wesentliche Techniken zum Filtern von Collections in MongoDB kennengelernt. Sie haben das Anwenden mehrerer Bedingungen mit den Operatoren $and und $or geübt, was die Erstellung komplexer und präziser Abfragen ermöglicht. Sie haben auch eine Reihe von Vergleichsoperatoren wie $gt, $lt und $ne erkundet, um Suchkriterien zu verfeinern. Darüber hinaus haben Sie Erfahrungen mit dem Abgleichen von Text mithilfe von regulären Ausdrücken, dem Prüfen der Existenz von Feldern mit $exists und dem Abfragen von null-Werten gesammelt. Diese Fähigkeiten bilden eine solide Grundlage für die effektive Datenabfrage und -manipulation in MongoDB.