MongoDB-Daten transformieren

Einführung

In diesem Lab erfahren Sie, wie Sie MongoDB-Daten mithilfe grundlegender Aggregationsoperationen transformieren können. Das Lab behandelt fünf Schlüsselschritte: die Auswahl der Ausgabefelder, die Umbenennung von Feldern, die Berechnung neuer Felder, die Formatierung der Ausgabe und die Filterung der Ergebnisse. Durch diese Schritte erhalten Sie praktische Erfahrungen beim Umgestalten und Analysieren von Daten, die in MongoDB-Sammlungen (collections) gespeichert sind. Das Lab bietet einen Beispieldatensatz von Büchern und zeigt, wie Sie die Aggregationspipeline nutzen können, um die Daten auf eine sinnvollere Weise zu extrahieren, zu manipulieren und darzustellen.

Skills Graph

Auswahl der Ausgabefelder

In diesem Schritt erfahren wir, wie wir die Aggregationspipeline von MongoDB nutzen können, um Ausgabefelder auszuwählen und zu transformieren. Aggregation ist eine leistungsstarke Methode zur Verarbeitung und Analyse von Daten in MongoDB.

Zunächst starten wir die MongoDB-Shell:

mongosh

Jetzt erstellen wir eine Beispielsammlung (collection) von Büchern, mit der wir arbeiten können:

use bookstore

db.books.insertMany([
    {
        title: "MongoDB Basics",
        author: "Jane Smith",
        price: 29.99,
        pages: 250,
        categories: ["Database", "Programming"]
    },
    {
        title: "Python Deep Dive",
        author: "John Doe",
        price: 39.99,
        pages: 450,
        categories: ["Programming", "Python"]
    },
    {
        title: "Data Science Handbook",
        author: "Alice Johnson",
        price: 49.99,
        pages: 600,
        categories: ["Data Science", "Programming"]
    }
])

Jetzt nutzen wir die Aggregationspipeline, um bestimmte Ausgabefelder auszuwählen:

db.books.aggregate([
  {
    $project: {
      _id: 0,
      bookTitle: "$title",
      bookAuthor: "$author"
    }
  }
]);

Beispielausgabe:

[
  { bookTitle: 'MongoDB Basics', bookAuthor: 'Jane Smith' },
  { bookTitle: 'Python Deep Dive', bookAuthor: 'John Doe' },
  { bookTitle: 'Data Science Handbook', bookAuthor: 'Alice Johnson' }
]

Lassen Sie uns analysieren, was wir getan haben:

• $project ist eine Aggregationsstufe (stage), die Dokumente umgestaltet
• _id: 0 schließt die Standard-MongoDB-Dokument-ID aus
• bookTitle: "$title" benennt das Feld 'title' in 'bookTitle' um
• bookAuthor: "$author" benennt das Feld 'author' in 'bookAuthor' um

Das $ vor Feldnamen teilt MongoDB mit, den Wert dieses Feldes zu verwenden.

Umbenennung von Feldern

In diesem Schritt werden wir fortgeschrittenere Techniken zur Umbenennung von Feldern mithilfe der Aggregationspipeline von MongoDB untersuchen. Wir bauen auf der Buchsammlung (collection) auf, die wir im vorherigen Schritt erstellt haben.

Lassen Sie uns in der MongoDB-Shell fortfahren:

mongosh

Zunächst wechseln wir zur bookstore-Datenbank:

use bookstore

Jetzt verwenden wir eine komplexere $project-Stufe (stage), um mehrere Felder umzubenennen und zu transformieren:

db.books.aggregate([
  {
    $project: {
      _id: 0,
      bookInfo: {
        name: "$title",
        writer: "$author",
        bookLength: "$pages",
        pricing: "$price"
      },
      genres: "$categories"
    }
  }
]);

Beispielausgabe:

[
  {
    bookInfo: {
      name: 'MongoDB Basics',
      writer: 'Jane Smith',
      bookLength: 250,
      pricing: 29.99
    },
    genres: [ 'Database', 'Programming' ]
  },
  //... andere Buchdokumente
]

Lassen Sie uns die Umbenennungstechnik analysieren:

• Wir haben ein verschachteltes Objekt bookInfo mit umbenannten Feldern erstellt
• name ersetzt title
• writer ersetzt author
• bookLength ersetzt pages
• pricing ersetzt price
• Wir haben auch die categories als genres beibehalten

Sie können auch die $rename-Stufe für eine einfachere Umbenennung von Feldern verwenden:

db.books.aggregate([
  {
    $rename: {
      title: "bookName",
      author: "bookWriter"
    }
  }
]);

Diese Stufe benennt Felder direkt in den ursprünglichen Dokumenten um.

Berechnung neuer Felder

In diesem Schritt erfahren wir, wie wir neue Felder erstellen können, indem wir Berechnungen mithilfe der Aggregationspipeline von MongoDB durchführen. Wir werden weiterhin mit unserer bookstore-Datenbank arbeiten.

Lassen Sie uns beginnen, indem wir die MongoDB-Shell starten:

mongosh

Wechseln Sie zur bookstore-Datenbank:

use bookstore

Wir verwenden die $addFields-Stufe (stage), um neue berechnete Felder zu erstellen:

db.books.aggregate([
  {
    $addFields: {
      totalValue: { $multiply: ["$price", 1.1] },
      discountedPrice: { $multiply: ["$price", 0.9] },
      pageCategories: {
        $concat: [
          { $toString: "$pages" },
          " page ",
          { $arrayElemAt: ["$categories", 0] }
        ]
      }
    }
  }
]);

Beispielausgabe:

[
  {
    _id: ObjectId("..."),
    title: "MongoDB Basics",
    author: "Jane Smith",
    price: 29.99,
    pages: 250,
    categories: ["Database", "Programming"],
    totalValue: 32.989,
    discountedPrice: 26.991,
    pageCategories: "250 page Database"
  },
  //... andere Buchdokumente
]

Lassen Sie uns die Berechnungen analysieren:

• totalValue: Multipliziert den Preis mit 1,1 (10 % Aufschlag)
• discountedPrice: Multipliziert den Preis mit 0,9 (10 % Rabatt)
• pageCategories: Kombiniert die Anzahl der Seiten mit der ersten Kategorie mithilfe von $concat

Wir können auch komplexere Berechnungen durchführen. Lassen Sie uns eine Buchbewertung basierend auf der Anzahl der Seiten berechnen:

db.books.aggregate([
  {
    $addFields: {
      bookRating: {
        $switch: {
          branches: [
            { case: { $lt: ["$pages", 300] }, then: "Short Book" },
            { case: { $lt: ["$pages", 500] }, then: "Medium Book" }
          ],
          default: "Long Book"
        }
      }
    }
  }
]);

Dieses Beispiel verwendet $switch, um Bücher basierend auf ihrer Seitenzahl zu kategorisieren.

Ausgabe formatieren

In diesem Schritt werden wir verschiedene Techniken zur Formatierung und Transformation der Ausgabe mithilfe der Aggregationspipeline von MongoDB untersuchen. Wir werden weiterhin mit unserer bookstore-Datenbank arbeiten.

Lassen Sie uns beginnen, indem wir die MongoDB-Shell starten:

mongosh

Wechseln Sie zur bookstore-Datenbank:

use bookstore

Zunächst verwenden wir $toUpper und $toLower, um Textfelder zu formatieren:

db.books.aggregate([
  {
    $project: {
      _id: 0,
      titleUpperCase: { $toUpper: "$title" },
      authorLowerCase: { $toLower: "$author" }
    }
  }
]);

Beispielausgabe:

[
  {
    titleUpperCase: 'MONGODB BASICS',
    authorLowerCase: 'jane smith'
  },
  //... andere Buchdokumente
]

Als Nächstes formatieren wir numerische Werte mit $round und erstellen formatierte Preiszeichenketten:

db.books.aggregate([
  {
    $project: {
      _id: 0,
      title: 1,
      roundedPrice: { $round: ["$price", 1] },
      formattedPrice: {
        $concat: ["$", { $toString: { $round: ["$price", 2] } }]
      }
    }
  }
]);

Beispielausgabe:

[
  {
    title: 'MongoDB Basics',
    roundedPrice: 30,
    formattedPrice: '$29.99'
  },
  //... andere Buchdokumente
]

Wir können auch Arrays formatieren und komplexe Zeichenkettenrepräsentationen erstellen:

db.books.aggregate([
  {
    $project: {
      _id: 0,
      title: 1,
      categoriesSummary: {
        $reduce: {
          input: "$categories",
          initialValue: "",
          in: {
            $concat: [
              "$$value",
              { $cond: [{ $eq: ["$$value", ""] }, "", ", "] },
              "$$this"
            ]
          }
        }
      }
    }
  }
]);

Beispielausgabe:

[
  {
    title: 'MongoDB Basics',
    categoriesSummary: 'Database, Programming'
  },
  //... andere Buchdokumente
]

Dieses letzte Beispiel verwendet $reduce, um Array-Elemente zu einer durch Kommas getrennten Zeichenkette zusammenzufügen.

Ergebnisse filtern

In diesem letzten Schritt werden wir verschiedene Filtertechniken mithilfe der Aggregationspipeline von MongoDB untersuchen. Wir werden weiterhin mit unserer bookstore-Datenbank arbeiten, um verschiedene Möglichkeiten zur Filterung von Ergebnissen zu demonstrieren.

Lassen Sie uns beginnen, indem wir die MongoDB-Shell starten:

mongosh

Wechseln Sie zur bookstore-Datenbank:

use bookstore

Zunächst filtern wir Bücher mit einfachen Vergleichsoperatoren:

db.books.aggregate([
  {
    $match: {
      price: { $gt: 30 },
      pages: { $lt: 500 }
    }
  }
]);

Diese Abfrage filtert Bücher, die:

• Einen Preis von mehr als 30 haben
• Weniger als 500 Seiten haben

Beispielausgabe:

[
  {
    _id: ObjectId("..."),
    title: "Python Deep Dive",
    author: "John Doe",
    price: 39.99,
    pages: 450,
    categories: ["Programming", "Python"]
  }
]

Als Nächstes verwenden wir komplexere Filterung mit Array-Operationen:

db.books.aggregate([
  {
    $match: {
      categories: { $in: ["Programming"] }
    }
  }
]);

Diese Abfrage findet alle Bücher, die "Programming" in ihren Kategorien haben.

Wir können auch mehrere Filtertechniken kombinieren:

db.books.aggregate([
  {
    $match: {
      $or: [{ pages: { $gt: 400 } }, { categories: { $in: ["Database"] } }]
    }
  },
  {
    $project: {
      title: 1,
      pages: 1,
      categories: 1
    }
  }
]);

Diese komplexere Abfrage:

• Findet Bücher mit mehr als 400 Seiten ODER in der Kategorie "Database"
• Projiziert nur bestimmte Felder in der Ausgabe

Beispielausgabe:

[
  {
    _id: ObjectId("..."),
    title: "Data Science Handbook",
    pages: 600,
    categories: ["Data Science", "Programming"]
  },
  {
    _id: ObjectId("..."),
    title: "MongoDB Basics",
    pages: 250,
    categories: ["Database", "Programming"]
  }
]

Zusammenfassung

In diesem Lab haben Sie gelernt, wie Sie die Aggregationspipeline von MongoDB verwenden, um Ausgabe-Felder auszuwählen und zu transformieren. Sie haben begonnen, indem Sie eine Beispielsammlung (collection) von Büchern erstellt haben. Anschließend haben Sie die $project-Stufe (stage) verwendet, um bestimmte Felder auszuwählen und umzubenennen. Sie haben auch fortgeschrittenere Techniken zur Umbenennung von Feldern untersucht, einschließlich der Verwendung von berechneten Ausdrücken und verschachtelten Feldern. Schließlich haben Sie gelernt, wie Sie neue Felder berechnen, die Ausgabe formatieren und die Ergebnisse filtern. Diese Fähigkeiten sind für die effiziente Verarbeitung und Analyse von Daten in MongoDB unerlässlich.