Abfragen von MongoDB-Arrays

MongoDBMongoDBBeginner
Jetzt üben

💡 Dieser Artikel wurde von AI-Assistenten übersetzt. Um die englische Version anzuzeigen, können Sie hier klicken

Einführung

In diesem Lab lernst du, wie du effektiv MongoDB-Arrays abfragen kannst. Das Lab behandelt verschiedene Techniken, darunter das Suchen nach bestimmten Elementen innerhalb von Arrays, die Verwendung von Array-Operatoren für komplexere Abfragen, das Finden von Dokumenten nach Arraygröße, das Abgleichen von Elementpositionen und das Filtern von Arraywerten. Diese Fähigkeiten sind unerlässlich, um mit den leistungsstarken Datenstrukturen von MongoDB umzugehen und es dir zu ermöglichen, effizient Daten zu erhalten und zu manipulieren, die in Arrayfeldern gespeichert sind.

Das Lab führt dich durch praktische Beispiele, beginnend mit der Erstellung einer Beispielsamling und der Exploration unterschiedlicher Abfrageverfahren. Am Ende dieses Labs wirst du eine solide Vorstellung davon haben, wie du die Arrayabfragefähigkeiten von MongoDB nutzen kannst, um deine Datenverwaltungszusammenhänge zu lösen.


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL mongodb(("MongoDB")) -.-> mongodb/QueryOperationsGroup(["Query Operations"]) mongodb(("MongoDB")) -.-> mongodb/DataTypesGroup(["Data Types"]) mongodb(("MongoDB")) -.-> mongodb/ArrayandEmbeddedDocumentsGroup(["Array and Embedded Documents"]) mongodb/QueryOperationsGroup -.-> mongodb/find_documents("Find Documents") mongodb/DataTypesGroup -.-> mongodb/work_with_array_data_types("Work with Array Data Types") mongodb/DataTypesGroup -.-> mongodb/manage_array_elements("Manage Array Elements") mongodb/ArrayandEmbeddedDocumentsGroup -.-> mongodb/query_embedded_documents("Query Embedded Documents") subgraph Lab Skills mongodb/find_documents -.-> lab-422090{{"Abfragen von MongoDB-Arrays"}} mongodb/work_with_array_data_types -.-> lab-422090{{"Abfragen von MongoDB-Arrays"}} mongodb/manage_array_elements -.-> lab-422090{{"Abfragen von MongoDB-Arrays"}} mongodb/query_embedded_documents -.-> lab-422090{{"Abfragen von MongoDB-Arrays"}} end

Arrayelemente durchsuchen

In diesem Schritt werden wir untersuchen, wie man in MongoDB-Arrays nach Elementen sucht. Arrays sind leistungsstarke Datenstrukturen, die es Ihnen ermöglichen, mehrere Werte in einem einzelnen Feld zu speichern, und MongoDB bietet flexible Möglichkeiten, diese Arrays abzufragen.

Lassen Sie uns zunächst die MongoDB-Shell starten und eine Beispielsamling mit Arraydaten erstellen:

mongosh

Jetzt erstellen wir eine Datenbank und fügen einige Dokumente mit Arrayfeldern hinzu:

use arraylab

db.products.insertMany([
    {
        name: "Laptop",
        tags: ["electronics", "computer", "work"],
        colors: ["silver", "black", "blue"]
    },
    {
        name: "Smartphone",
        tags: ["electronics", "mobile", "communication"],
        colors: ["red", "blue", "green"]
    },
    {
        name: "Headphones",
        tags: ["electronics", "audio", "music"],
        colors: ["black", "white"]
    }
])

Lassen Sie uns nach Dokumenten suchen, die ein bestimmtes Element in einem Array enthalten:

db.products.find({ tags: "electronics" });

Diese Abfrage gibt alle Dokumente zurück, in denen "electronics" im tags-Array vorhanden ist.

Beispielausgabe:

[
  {
    _id: ObjectId("..."),
    name: 'Laptop',
    tags: [ 'electronics', 'computer', 'work' ],
    colors: [ 'silver', 'black', 'blue' ]
  },
  {
    _id: ObjectId("..."),
    name: 'Smartphone',
    tags: [ 'electronics','mobile', 'communication' ],
    colors: [ 'red', 'blue', 'green' ]
  },
  {
    _id: ObjectId("..."),
    name: 'Headphones',
    tags: [ 'electronics', 'audio','music' ],
    colors: [ 'black', 'white' ]
  }
]

Sie können auch nach Dokumenten suchen, in denen ein Array mehrere bestimmte Elemente enthält:

db.products.find({ colors: { $all: ["black", "blue"] } });

Diese Abfrage findet Produkte, die sowohl "black" als auch "blue" in ihrem colors-Array haben.

Arrayoperatoren verwenden

In diesem Schritt werden wir tiefer in die MongoDB-Arrayabfrage eintauchen, indem wir leistungsstarke Arrayoperatoren erkunden, die komplexere und präzisere Suchanforderungen ermöglichen.

Wir werden fortfahren, die Datenbank und die Sammlung aus dem vorherigen Schritt zu verwenden. Wenn Sie die MongoDB-Shell geschlossen haben, starten Sie sie erneut und wählen Sie die Datenbank aus:

mongosh
use arraylab

Lassen Sie uns zunächst den $elemMatch-Operator kennenlernen, der es ermöglicht, Dokumente zu finden, bei denen mindestens ein Arrayelement mehreren Bedingungen entspricht:

db.products.insertMany([
  {
    name: "Gaming Laptop",
    specs: [
      { ram: 16, storage: 512, price: 1200 },
      { ram: 32, storage: 1024, price: 2000 }
    ]
  },
  {
    name: "Office Laptop",
    specs: [
      { ram: 8, storage: 256, price: 600 },
      { ram: 16, storage: 512, price: 800 }
    ]
  }
]);

// Find laptops with specs having RAM >= 16 and price > 1000
db.products.find({
  specs: {
    $elemMatch: {
      ram: { $gte: 16 },
      price: { $gt: 1000 }
    }
  }
});

Als nächstes werden wir den $size-Operator erkunden, um Dokumente mit Arrays einer bestimmten Länge zu finden:

// Find products with exactly 2 colors
db.products.find({ colors: { $size: 2 } });

Wir werden auch den $slice-Operator demonstrieren, um einen Teilsatz von Arrayelementen abzurufen:

// Retrieve only the first two tags from each product
db.products.find({}, { tags: { $slice: 2 } });

Beispielausgabe:

[
  {
    _id: ObjectId("..."),
    name: 'Laptop',
    tags: [ 'electronics', 'computer' ]
  },
  {
    _id: ObjectId("..."),
    name: 'Smartphone',
    tags: [ 'electronics','mobile' ]
  }
]

Nach Arraygröße suchen

In diesem Schritt werden wir untersuchen, wie man MongoDB-Dokumente abfragt, basierend auf der Größe ihrer Arrays. Der $size-Operator ermöglicht es Ihnen, Dokumente mit Arrays zu finden, die eine bestimmte Anzahl von Elementen haben.

Lassen Sie uns zunächst die MongoDB-Shell starten und sicherstellen, dass wir unsere vorherige Datenbank verwenden:

mongosh
use arraylab

Fügen Sie einige weitere Dokumente mit unterschiedlichen Arraygrößen hinzu, um unsere Abfragen zu demonstrieren:

db.products.insertMany([
  {
    name: "Basic Laptop",
    features: ["wifi"],
    accessories: ["charger"]
  },
  {
    name: "Advanced Laptop",
    features: ["wifi", "bluetooth", "touchscreen"],
    accessories: ["charger", "mouse", "case"]
  },
  {
    name: "Premium Laptop",
    features: ["wifi", "bluetooth", "touchscreen", "4K display"],
    accessories: ["charger", "mouse", "case", "keyboard"]
  }
]);

Jetzt lassen Sie uns Dokumente mit Arrays von bestimmten Größen abfragen:

// Find products with exactly 1 feature
db.products.find({ features: { $size: 1 } });

// Find products with 3 features
db.products.find({ features: { $size: 3 } });

// Find products with 4 accessories
db.products.find({ accessories: { $size: 4 } });

Beispielausgabe:

// Products with 1 feature
[
  {
    _id: ObjectId("..."),
    name: 'Basic Laptop',
    features: [ 'wifi' ],
    accessories: [ 'charger' ]
  }
]

// Products with 3 features
[
  {
    _id: ObjectId("..."),
    name: 'Advanced Laptop',
    features: [ 'wifi', 'bluetooth', 'touchscreen' ],
    accessories: [ 'charger','mouse', 'case' ]
  }
]

// Products with 4 accessories
[
  {
    _id: ObjectId("..."),
    name: 'Premium Laptop',
    features: [ 'wifi', 'bluetooth', 'touchscreen', '4K display' ],
    accessories: [ 'charger','mouse', 'case', 'keyboard' ]
  }
]

Sie können auch den $size-Operator mit anderen Abfragebedingungen kombinieren:

// Find products with exactly 3 features and more than 2 accessories
db.products.find({
  features: { $size: 3 },
  accessories: { $size: { $gt: 2 } }
});

Elementposition abgleichen

In diesem Schritt werden wir lernen, wie man MongoDB-Arrays abfragt, indem man spezifische Elementpositionen abgleicht. MongoDB bietet leistungsstarke Möglichkeiten, um nach Elementen an exakten Positionen innerhalb eines Arrays zu suchen.

Lassen Sie uns zunächst die MongoDB-Shell starten und sicherstellen, dass wir unsere vorherige Datenbank verwenden:

mongosh
use arraylab

Lassen Sie uns eine neue Sammlung mit Dokumenten erstellen, die Arrays haben, bei denen die Position der Elemente wichtig ist:

db.courses.insertMany([
  {
    name: "Web Development Bootcamp",
    modules: ["HTML", "CSS", "JavaScript", "React", "Node.js"],
    difficulty: ["beginner", "intermediate", "advanced"]
  },
  {
    name: "Data Science Course",
    modules: [
      "Python",
      "Statistics",
      "Machine Learning",
      "Deep Learning",
      "AI"
    ],
    difficulty: ["intermediate", "advanced", "expert"]
  },
  {
    name: "Cybersecurity Program",
    modules: [
      "Network Security",
      "Ethical Hacking",
      "Cryptography",
      "Penetration Testing",
      "Incident Response"
    ],
    difficulty: ["intermediate", "advanced", "expert"]
  }
]);

Jetzt lassen Sie uns Dokumente abfragen, indem wir Elemente an bestimmten Arraypositionen abgleichen:

// Find courses where the first module is "HTML"
db.courses.find({ "modules.0": "HTML" });

// Find courses where the third module is "JavaScript"
db.courses.find({ "modules.2": "JavaScript" });

// Find courses where the second difficulty level is "advanced"
db.courses.find({ "difficulty.1": "advanced" });

Beispielausgabe:

// Courses with HTML as the first module
[
  {
    _id: ObjectId("..."),
    name: 'Web Development Bootcamp',
    modules: [ 'HTML', 'CSS', 'JavaScript', 'React', 'Node.js' ],
    difficulty: [ 'beginner', 'intermediate', 'advanced' ]
  }
]

// Courses with JavaScript as the third module
[
  {
    _id: ObjectId("..."),
    name: 'Web Development Bootcamp',
    modules: [ 'HTML', 'CSS', 'JavaScript', 'React', 'Node.js' ],
    difficulty: [ 'beginner', 'intermediate', 'advanced' ]
  }
]

// Courses with "advanced" as the second difficulty level
[
  {
    _id: ObjectId("..."),
    name: 'Data Science Course',
    modules: [ 'Python', 'Statistics', 'Machine Learning', 'Deep Learning', 'AI' ],
    difficulty: [ 'intermediate', 'advanced', 'expert' ]
  },
  {
    _id: ObjectId("..."),
    name: 'Cybersecurity Program',
    modules: [ 'Network Security', 'Ethical Hacking', 'Cryptography', 'Penetration Testing', 'Incident Response' ],
    difficulty: [ 'intermediate', 'advanced', 'expert' ]
  }
]

Sie können auch positionbasierte Abfragen mit anderen Bedingungen kombinieren:

// Find courses where the first module is "HTML" and the second difficulty is "intermediate"
db.courses.find({
  "modules.0": "HTML",
  "difficulty.1": "intermediate"
});

Arraywerte filtern

In diesem letzten Schritt werden wir fortgeschrittene Techniken zum Filtern von Arraywerten in MongoDB erkunden, indem wir Vergleichs- und logische Operatoren verwenden, um komplexe Abfragen zu erstellen.

Lassen Sie uns zunächst die MongoDB-Shell starten und sicherstellen, dass wir unsere vorherige Datenbank verwenden:

mongosh
use arraylab

Lassen Sie uns eine Sammlung von Produkten mit komplexeren Arraystrukturen erstellen:

db.electronics.insertMany([
  {
    name: "Smartphone",
    specs: [
      { ram: 6, storage: 128, price: 499 },
      { ram: 8, storage: 256, price: 599 }
    ],
    tags: ["mobile", "communication", "high-end"],
    ratings: [4.5, 4.7, 4.6]
  },
  {
    name: "Laptop",
    specs: [
      { ram: 16, storage: 512, price: 1200 },
      { ram: 32, storage: 1024, price: 2000 }
    ],
    tags: ["computer", "work", "professional"],
    ratings: [4.8, 4.9, 4.7]
  },
  {
    name: "Tablet",
    specs: [
      { ram: 4, storage: 64, price: 299 },
      { ram: 8, storage: 256, price: 499 }
    ],
    tags: ["mobile", "entertainment"],
    ratings: [4.2, 4.3, 4.1]
  }
]);

Lassen Sie uns verschiedene Filtertechniken erkunden:

  1. Filtern nach Arrayelementvergleich:
// Find devices with at least one spec having RAM >= 16
db.electronics.find({
  specs: {
    $elemMatch: { ram: { $gte: 16 } }
  }
});

// Find devices with ratings above 4.5
db.electronics.find({
  ratings: { $gt: 4.5 }
});
  1. Verwenden von logischen Operatoren mit Arrays:
// Find devices with both "mobile" and "communication" tags
db.electronics.find({
  tags: { $all: ["mobile", "communication"] }
});

// Find devices with either "work" or "entertainment" tags
db.electronics.find({
  tags: { $in: ["work", "entertainment"] }
});
  1. Komplexes Filtern mit mehreren Bedingungen:
// Find devices with specs having RAM >= 8 and price <= 1000
db.electronics.find({
  specs: {
    $elemMatch: {
      ram: { $gte: 8 },
      price: { $lte: 1000 }
    }
  }
});

Beispielausgabe:

// Devices with RAM >= 16
[
  {
    _id: ObjectId("..."),
    name: 'Laptop',
    specs: [
      { ram: 16, storage: 512, price: 1200 },
      { ram: 32, storage: 1024, price: 2000 }
    ],
    tags: [ 'computer', 'work', 'professional' ],
    ratings: [ 4.8, 4.9, 4.7 ]
  }
]

// Devices with ratings above 4.5
[
  {
    _id: ObjectId("..."),
    name: 'Smartphone',
    ratings: [ 4.5, 4.7, 4.6 ]
  },
  {
    _id: ObjectId("..."),
    name: 'Laptop',
    ratings: [ 4.8, 4.9, 4.7 ]
  }
]

Zusammenfassung

In diesem Lab haben Sie gelernt, wie man in MongoDB-Arrays nach Elementen sucht, indem man verschiedene Arrayoperatoren verwendet, um komplexere und präzisere Suchanforderungen durchzuführen. Sie haben Techniken zur Suche nach Dokumenten basierend auf der Anwesenheit spezifischer Elemente in einem Array sowie der Größe und Position von Arrayelementen untersucht. Diese Fähigkeiten ermöglichen es Ihnen, die in MongoDBs flexiblen Array-Datenstrukturen gespeicherten Daten effektiv abzufragen und zu manipulieren, was Ihnen ermöglicht, leistungsstarke und effiziente Anwendungen zu entwickeln.