MongoDB-Einträge aktualisieren

Einführung

In diesem Lab erfahren Sie, wie Sie MongoDB-Einträge mit verschiedenen Techniken aktualisieren können, darunter das Aktualisieren eines einzelnen Dokuments, das Durchführen von Massenaktualisierungen und die Verwendung von Update-Operatoren. Sie werden auch untersuchen, wie Sie die Update-Ergebnisse verarbeiten und die aktualisierten Daten überprüfen können. Dieses Lab behandelt die grundlegenden CRUD-Operationen (Create, Read, Update, Delete) in MongoDB und vermittelt Ihnen die erforderlichen Fähigkeiten, um Ihre Daten in einer MongoDB-Datenbank effektiv zu verwalten.

Das Lab beginnt mit der Demonstration, wie Sie ein einzelnes Dokument mit der Methode updateOne() aktualisieren können, gefolgt von der Untersuchung von Massenaktualisierungen mit der Methode updateMany(). Anschließend werden Sie die Verwendung von Update-Operatoren wie $set kennenlernen, um bestimmte Felder innerhalb von Dokumenten zu ändern. Darüber hinaus erfahren Sie, wie Sie die Update-Ergebnisse verarbeiten und die aktualisierten Daten überprüfen können, um die Integrität Ihrer MongoDB-Einträge sicherzustellen.

Einzelnes Dokument aktualisieren

In diesem Schritt erfahren Sie, wie Sie ein einzelnes Dokument in MongoDB mit der Methode updateOne() aktualisieren können. Wir werden weiterhin mit unserer Bücher-Sammlung arbeiten und zeigen, wie Sie bestimmte Attribute eines Dokuments ändern können.

Zunächst verbinden wir uns mit der MongoDB-Shell und wechseln zur Datenbank mylab_database:

mongosh
use mylab_database

Lassen Sie uns zunächst die aktuellen Bücher in unserer Sammlung überprüfen:

db.books.find()

Sie sollten die Liste der Bücher sehen, die wir zuvor hinzugefügt haben:

[
  {
    _id: ObjectId('674681ac7b1f6d3a37c1c18c'),
    title: 'JavaScript Fundamentals',
    author: 'Mike Johnson',
    year: 2022,
    pages: 350
  },
  {
    _id: ObjectId('674681ac7b1f6d3a37c1c18d'),
    title: 'Python Deep Dive',
    author: 'Sarah Williams',
    year: 2021,
    pages: 450
  },
  {
    _id: ObjectId('674681ac7b1f6d3a37c1c18e'),
    title: 'Machine Learning Basics',
    author: 'John Doe',
    year: 2020,
    price: 39.99
  }
]

Nun verwenden wir die Methode updateOne(), um ein bestimmtes Dokument zu ändern. Wir werden das Buch "JavaScript Fundamentals" aktualisieren, um seine Seitenzahl zu ändern:

db.books.updateOne(
    { title: "JavaScript Fundamentals" },
    { $set: { pages: 400 } }
)

Lassen Sie uns diesen Befehl analysieren:

• Das erste Argument { title: "JavaScript Fundamentals" } ist der Filter, der das spezifische Dokument zum Aktualisieren findet.
• $set ist ein Update-Operator, der den Wert eines bestimmten Feldes ändert.
• { pages: 400 } setzt die neue Seitenzahl auf 400.

Um die Aktualisierung zu überprüfen, suchen wir das Dokument erneut:

db.books.find({ title: "JavaScript Fundamentals" })

Sie sollten das Dokument mit der aktualisierten Seitenzahl von 400 sehen.

Massenaktualisierungen durchführen

In diesem Schritt erfahren Sie, wie Sie Massenaktualisierungen in MongoDB mit der Methode updateMany() durchführen können. Massenaktualisierungen sind sehr nützlich, wenn Sie mehrere Dokumente ändern müssen, die einer bestimmten Bedingung entsprechen.

Fügen wir zunächst einige weitere Bücher zu unserer Sammlung hinzu, um Massenaktualisierungen zu demonstrieren:

db.books.insertMany([
    {
        title: "Advanced Python",
        author: "John Doe",
        year: 2019,
        price: 44.99
    },
    {
        title: "Data Science Handbook",
        author: "Jane Smith",
        year: 2021,
        price: 49.99
    }
])

Nun führen wir eine Massenaktualisierung durch, um den Preis aller Bücher von John Doe um 10 Dollar zu erhöhen:

db.books.updateMany(
    { author: "John Doe" },
    { $inc: { price: 10 } }
)

Analysieren wir diesen Befehl:

• { author: "John Doe" } wählt alle Bücher von John Doe aus.
• $inc ist ein Update-Operator, der das angegebene Feld erhöht.
• { price: 10 } erhöht den Preis um 10.

Überprüfen Sie die Aktualisierung, indem Sie alle Bücher von John Doe suchen:

db.books.find({ author: "John Doe" })

Sie sollten sehen, dass die Preise für "Machine Learning Basics" und "Advanced Python" um 10 Dollar erhöht wurden.

Führen wir noch eine weitere Massenaktualisierung durch, indem wir allen Büchern, die vor 2021 veröffentlicht wurden, eine Kategorie hinzufügen:

db.books.updateMany(
    { year: { $lt: 2021 } },
    { $set: { category: "Older Publication" } }
)

Hier bedeutet $lt "weniger als". Mit diesem Befehl werden alle Bücher, die vor 2021 veröffentlicht wurden, aktualisiert, indem die Kategorie "Older Publication" hinzugefügt wird.

Update-Operatoren verwenden

In diesem Schritt werden Sie leistungsstarke MongoDB-Update-Operatoren kennenlernen, die es Ihnen ermöglichen, komplexe Dokumentmodifikationen durchzuführen, die über einfache Wertänderungen hinausgehen.

Erstellen wir zunächst einige Beispieldaten, mit denen wir arbeiten können:

db.products.insertMany([
    {
        name: "Laptop",
        price: 1000,
        tags: ["electronics", "computer"],
        stock: 50
    },
    {
        name: "Smartphone",
        price: 800,
        tags: ["electronics", "mobile"],
        stock: 30
    }
])

MongoDB bietet mehrere leistungsstarke Update-Operatoren, die es Ihnen ermöglichen, Dokumente auf raffinierte Weise zu modifizieren:

1. $mul-Operator - Multiplizieren von numerischen Werten

db.products.updateOne(
    { name: "Laptop" },
    { $mul: { price: 1.1 } }
)

Die Ausgabe:

{
  acknowledged: true,
  insertedId: null,
  matchedCount: 1,
  modifiedCount: 1,
  upsertedCount: 0,
  upsertedId: null
}

Der $mul-Operator multipliziert den Wert eines Feldes mit der angegebenen Zahl. In diesem Beispiel erhöhen wir den Preis des Laptops um 10 %.

2. $push-Operator - Hinzufügen von Elementen zu einem Array

db.products.updateOne(
    { name: "Smartphone" },
    { $push: { tags: "sale" } }
)

Die Ausgabe:

{
  acknowledged: true,
  insertedId: null,
  matchedCount: 1,
  modifiedCount: 1,
  upsertedCount: 0,
  upsertedId: null
}

Der $push-Operator fügt ein Element zu einem Array-Feld hinzu. Hier fügen wir ein "sale"-Tag zu den Tags des Smartphones hinzu.

3. $min- und $max-Operatoren - Aktualisierung basierend auf einem Vergleich

db.products.updateOne(
    { name: "Laptop" },
    {
        $min: { stock: 40 },
        $max: { price: 1200 }
    }
)

Die Ausgabe:

{
  acknowledged: true,
  insertedId: null,
  matchedCount: 1,
  modifiedCount: 1,
  upsertedCount: 0,
  upsertedId: null
}

• $min aktualisiert das Feld, wenn der angegebene Wert kleiner als der vorhandene Wert ist.
• $max aktualisiert das Feld, wenn der angegebene Wert größer als der vorhandene Wert ist.

Lassen Sie uns unsere Aktualisierungen überprüfen:

db.products.find()

[
  {
    _id: ObjectId('674683aebec38876f7c1c18e'),
    name: 'Laptop',
    price: 1200,
    tags: [ 'electronics', 'computer' ],
    stock: 40
  },
  {
    _id: ObjectId('674683aebec38876f7c1c18f'),
    name: 'Smartphone',
    price: 800,
    tags: [ 'electronics', 'mobile', 'sale' ],
    stock: 30
  }
]

Sie sollten die modifizierten Dokumente mit aktualisierten Preisen, Tags und Lagerbeständen sehen.

Update-Ergebnisse verarbeiten

In diesem Schritt erfahren Sie, wie Sie die Ergebnisse von Update-Operationen in MongoDB verarbeiten und interpretieren können. Das Verständnis der Update-Ergebnisse hilft Ihnen, zu überprüfen, ob Ihre Aktualisierungen erfolgreich waren, und deren Auswirkungen zu verstehen.

Erstellen wir zunächst einige Beispieldaten, mit denen wir arbeiten können:

db.users.insertMany([
    { name: "Alice", age: 28, status: "active" },
    { name: "Bob", age: 35, status: "inactive" },
    { name: "Charlie", age: 42, status: "active" }
])

Nun lassen Sie uns verschiedene Eigenschaften der Update-Ergebnisse untersuchen:

1. Grundlegendes Update-Ergebnis

const result = db.users.updateOne(
    { name: "Alice" },
    { $set: { age: 29 } }
)

print("Matched Documents: " + result.matchedCount)
print("Modified Documents: " + result.modifiedCount)

Die Ausgabe:

Matched Documents: 1
Modified Documents: 1

Das Ergebnisobjekt bietet zwei Schlüssel-Eigenschaften:

• matchedCount: Anzahl der Dokumente, die dem Filter entsprechen
• modifiedCount: Anzahl der tatsächlich geänderten Dokumente

Dies hilft Ihnen, genau zu verstehen, was während der Update-Operation passiert ist. Wenn matchedCount 0 ist, wurden keine Dokumente gefunden. Wenn modifiedCount 0 ist, wurden keine Änderungen vorgenommen, auch wenn ein Dokument übereinstimmte.

2. Upsert-Operation

db.users.updateOne(
    { name: "David" },
    { $set: { name: "David", age: 25, status: "active" } },
    { upsert: true }
)

Ein Upsert erstellt ein neues Dokument, wenn kein passendes Dokument gefunden wird:

3. Massen-Update-Ergebnisse

db.users.updateMany(
    { status: "active" },
    { $inc: { age: 1 } }
)

Dies zeigt, wie Sie Ergebnisse aus einer Massen-Update-Operation erhalten können, indem Sie anzeigen, wie viele aktive Benutzer übereinstimmten und geändert wurden.

Lassen Sie uns unsere Aktualisierungen überprüfen:

db.users.find()

Aktualisierte Daten überprüfen

In diesem Schritt lernen Sie verschiedene Methoden kennen, um aktualisierte Daten in MongoDB zu überprüfen und abzufragen. Das Bestätigen Ihrer Aktualisierungen ist entscheidend für die Aufrechterhaltung der Datenintegrität und die Gewährleistung, dass Ihre Änderungen korrekt angewendet wurden.

Erstellen wir zunächst einige Beispieldaten, um Überprüfungstechniken zu erkunden:

db.inventory.insertMany([
    {
        item: "laptop",
        quantity: 25,
        status: "available",
        category: "electronics"
    },
    {
        item: "smartphone",
        quantity: 15,
        status: "low stock",
        category: "mobile"
    }
])

1. Exakte Übereinstimmungsabfrage für präzise Überprüfung

db.inventory.updateOne(
    { item: "laptop" },
    { $set: { quantity: 30 } }
)

const laptopUpdate = db.inventory.findOne({
    item: "laptop",
    quantity: 30
})

print("Laptop Update Verified: " + (laptopUpdate!== null))

Die Ausgabe:

Laptop Update Verified: true

Diese Methode überprüft, ob ein Dokument mit genau den aktualisierten Werten existiert. Es ist die direkteste Möglichkeit, eine bestimmte Aktualisierung zu bestätigen.

2. Bereichsbasierte Überprüfung

db.inventory.updateMany(
    { status: "low stock" },
    { $inc: { quantity: 5 } }
)

const updatedItems = db.inventory.find({
    quantity: { $gte: 20 }
}).toArray()

print("Updated Low Stock Items: " + updatedItems.length)

Die Ausgabe:

Updated Low Stock Items: 2

Die Verwendung von Vergleichsoperatoren wie $gte (größer oder gleich) ermöglicht es Ihnen, Aktualisierungen über mehrere Dokumente hinweg zu überprüfen.

3. Komplexe Abfrageüberprüfung

db.inventory.updateOne(
    { item: "smartphone" },
    { $set: { status: "in stock" } }
)

const verifyUpdate = db.inventory.findOne({
    item: "smartphone",
    status: "in stock",
    category: "mobile"
})

print("Smartphone Status Updated: " + (verifyUpdate!== null))

Die Ausgabe:

Smartphone Status Updated: true

Dies zeigt eine komplexere Überprüfung, die mehrere Bedingungen gleichzeitig überprüft.

Lassen Sie uns alle Dokumente anzeigen, um unsere Aktualisierungen zu bestätigen:

db.inventory.find()

Zusammenfassung

In diesem Lab haben Sie gelernt, wie Sie einzelne und mehrere Dokumente in einer MongoDB-Datenbank aktualisieren können. Sie haben begonnen, die Methode updateOne() zu verwenden, um ein bestimmtes Dokument zu ändern, indem Sie die Seitenzahl des Buches "JavaScript Fundamentals" geändert haben. Anschließend haben Sie die Möglichkeit erkundet, Massenaktualisierungen mit der Methode updateMany() durchzuführen, die es Ihnen ermöglicht, mehrere Dokumente zu ändern, die einer bestimmten Bedingung entsprechen. Darüber hinaus haben Sie verschiedene Update-Operatoren kennengelernt, wie beispielsweise $set, den Sie verwendet haben, um Feldwerte zu ändern. Schließlich haben Sie die aktualisierten Daten überprüft, um sicherzustellen, dass die Änderungen erfolgreich angewendet wurden.