MongoDB-Daten gruppieren

Einführung

In diesem Labyrinth lernen Sie, wie Sie in MongoDB grundlegende Aggregationsoperationen durchführen, einschließlich des Gruppierens von Daten nach einem einzelnen Feld, der Berechnung von Gruppensummen, der Zählung von Gruppenmitgliedern, des Filters von Gruppen und der Sortierung von Gruppenergebnissen. Diese Fähigkeiten sind unerlässlich für die Datenanalyse und das Gewinn von Erkenntnissen aus Ihren MongoDB-Daten.

Das Lab behandelt eine Reihe von Aggregationstechniken, beginnend mit der Gruppierung von Daten nach einem einzelnen Feld und erweitert sich dann auf komplexere Operationen wie das Berechnen von Durchschnittswerten, Zählungen und das Filtern von Gruppen. Am Ende des Labs werden Sie eine solide Vorstellung davon haben, wie Sie die Aggregierungsframework von MongoDB nutzen, um die Macht Ihrer Daten zu entfesseln.

Gruppieren nach einem einzelnen Feld

In diesem Schritt lernen Sie, wie Sie Daten nach einem einzelnen Feld gruppieren, indem Sie das Aggregierungsframework von MongoDB verwenden. Das Gruppieren ermöglicht es Ihnen, Daten basierend auf einem bestimmten Feld zu organisieren und zu zusammenfassen, was für die Datenanalyse von entscheidender Bedeutung ist.

Lassen Sie uns zunächst mit dem Start der MongoDB-Shell beginnen:

mongosh

Erstellen wir nun eine Beispielsammlung von Produkten, um das Gruppieren zu demonstrieren:

use salesdb

db.products.insertMany([
    { category: "Electronics", price: 500 },
    { category: "Clothing", price: 50 },
    { category: "Electronics", price: 300 },
    { category: "Books", price: 25 },
    { category: "Clothing", price: 75 },
    { category: "Books", price: 40 }
])

Als Nächstes verwenden wir den Aggregierungsoperator $group, um die Produkte nach ihrer Kategorie zu gruppieren und den Gesamtpreis für jede Kategorie zu berechnen:

db.products.aggregate([
  {
    $group: {
      _id: "$category",
      totalPrice: { $sum: "$price" }
    }
  }
]);

Beispielausgabe

[
  { _id: 'Electronics', totalPrice: 800 },
  { _id: 'Clothing', totalPrice: 125 },
  { _id: 'Books', totalPrice: 65 }
]

Analysieren wir die Aggregationspipeline:

• $group: Gruppiert Dokumente nach einem angegebenen Ausdruck
• _id: "$category": Gibt an, dass wir nach dem Kategoriefeld gruppieren
• totalPrice: { $sum: "$price" }: Berechnet den Gesamtpreis für jede Kategorie

Berechnung von Gruppensummen

In diesem Schritt erweitern wir unsere bisherigen Gruppierungsfähigkeiten, indem wir lernen, wie wir verschiedene Aggregationssummen mit dem Aggregierungsframework von MongoDB berechnen. Wir werden mehrere Aggregierungsoperatoren verwenden, um komplexere Erkenntnisse aus unseren Produkt-Daten zu ziehen.

Lassen Sie uns mit der salesdb-Datenbank und der products-Sammlung fortfahren, die wir im vorherigen Schritt erstellt haben:

// Stellen Sie sicher, dass wir in der richtigen Datenbank sind
use salesdb

Wir werden verschiedene Aggregierungsoperatoren untersuchen, um Gruppensummen zu berechnen:

1. Berechnen Sie den Durchschnittspreis pro Kategorie:

db.products.aggregate([
  {
    $group: {
      _id: "$category",
      averagePrice: { $avg: "$price" }
    }
  }
]);

2. Finden Sie den höchsten und niedrigsten Preis in jeder Kategorie:

db.products.aggregate([
  {
    $group: {
      _id: "$category",
      maxPrice: { $max: "$price" },
      minPrice: { $min: "$price" }
    }
  }
]);

3. Kombinieren Sie mehrere Berechnungen in einer einzelnen Aggregation:

db.products.aggregate([
  {
    $group: {
      _id: "$category",
      totalPrice: { $sum: "$price" },
      averagePrice: { $avg: "$price" },
      productCount: { $sum: 1 }
    }
  }
]);

Beispielausgabe

[
  {
    _id: 'Electronics',
    totalPrice: 800,
    averagePrice: 400,
    productCount: 2
  },
  {
    _id: 'Clothing',
    totalPrice: 125,
    averagePrice: 62.5,
    productCount: 2
  },
  {
    _id: 'Books',
    totalPrice: 65,
    averagePrice: 32.5,
    productCount: 2
  }
]

Erläuterung der wichtigsten Aggregierungsoperatoren:

• $avg: Berechnet den Durchschnitt von numerischen Werten
• $max: Findet den maximalen Wert
• $min: Findet den minimalen Wert
• $sum: 1: Zählt die Anzahl der Dokumente in jeder Gruppe

Zählen von Gruppenmitgliedern

In diesem Schritt werden wir verschiedene Möglichkeiten zur Zählung von Elementen innerhalb von Gruppen mit dem Aggregierungsframework von MongoDB erkunden. Zählen ist eine grundlegende Operation, die Ihnen hilft, die Verteilung Ihrer Daten zu verstehen.

Lassen Sie uns mit unserer salesdb-Datenbank fortfahren:

// Stellen Sie sicher, dass wir in der richtigen Datenbank sind
use salesdb

Zunächst fügen wir mehr Produkte hinzu, um unsere Zählung interessanter zu gestalten:

db.products.insertMany([
  { category: "Electronics", brand: "Apple" },
  { category: "Electronics", brand: "Samsung" },
  { category: "Clothing", brand: "Nike" },
  { category: "Clothing", brand: "Adidas" },
  { category: "Books", brand: "Penguin" },
  { category: "Books", brand: "Oxford" }
]);

Jetzt werden wir auf verschiedene Weise zählen:

1. Zählen Sie die Anzahl der Produkte in jeder Kategorie:

db.products.aggregate([
  {
    $group: {
      _id: "$category",
      productCount: { $sum: 1 }
    }
  }
]);

2. Zählen Sie die eindeutigen Marken innerhalb jeder Kategorie:

db.products.aggregate([
  {
    $group: {
      _id: "$category",
      uniqueBrands: { $addToSet: "$brand" }
    }
  }
]);

3. Zählen Sie die Anzahl der eindeutigen Marken und die Gesamtzahl der Produkte:

db.products.aggregate([
  {
    $group: {
      _id: "$category",
      totalProducts: { $sum: 1 },
      uniqueBrands: { $addToSet: "$brand" },
      brandCount: { $addToSet: "$brand" }
    }
  },
  {
    $project: {
      totalProducts: 1,
      uniqueBrandCount: { $size: "$uniqueBrands" }
    }
  }
]);

Beispielausgabe

[
  {
    _id: 'Electronics',
    totalProducts: 4,
    uniqueBrandCount: 2
  },
  {
    _id: 'Clothing',
    totalProducts: 4,
    uniqueBrandCount: 2
  },
  {
    _id: 'Books',
    totalProducts: 4,
    uniqueBrandCount: 2
  }
]

Erläuterung der wichtigsten Aggregierungsoperatoren:

• $sum: 1: Zählt die Gesamtzahl der Dokumente in jeder Gruppe
• $addToSet: Erstellt ein Array von eindeutigen Werten
• $size: Zählt die Anzahl der Elemente in einem Array

Filtern von Gruppen

In diesem Schritt lernen Sie, wie Sie Gruppen mit dem Aggregierungsframework von MongoDB filtern. Das Filtern ermöglicht es Ihnen, sich auf spezifische Teilmengen Ihrer gruppierten Daten zu konzentrieren und gezieltere Erkenntnisse zu gewinnen.

Lassen Sie uns mit unserer salesdb-Datenbank fortfahren:

// Stellen Sie sicher, dass wir in der richtigen Datenbank sind
use salesdb

Fügen wir einigen Preisinformationen zu unseren vorhandenen Produkten hinzu, um das Filtern sinnvoller zu gestalten:

db.products.updateMany(
  { category: "Electronics", brand: "Apple" },
  { $set: { price: 1000 } }
);

db.products.updateMany(
  { category: "Electronics", brand: "Samsung" },
  { $set: { price: 800 } }
);

db.products.updateMany(
  { category: "Clothing", brand: "Nike" },
  { $set: { price: 100 } }
);

db.products.updateMany(
  { category: "Clothing", brand: "Adidas" },
  { $set: { price: 80 } }
);

Jetzt werden wir verschiedene Filtertechniken erkunden:

1. Filtern von Gruppen mit mehr als einem Produkt:

db.products.aggregate([
  {
    $group: {
      _id: "$category",
      products: { $push: "$brand" },
      productCount: { $sum: 1 }
    }
  },
  {
    $match: {
      productCount: { $gt: 1 }
    }
  }
]);

2. Filtern von Gruppen mit einem Gesamtpreis über einem bestimmten Schwellenwert:

db.products.aggregate([
  {
    $group: {
      _id: "$category",
      totalPrice: { $sum: "$price" },
      products: { $push: "$brand" }
    }
  },
  {
    $match: {
      totalPrice: { $gt: 500 }
    }
  }
]);

3. Komplexes Filtern mit mehreren Bedingungen:

db.products.aggregate([
  {
    $group: {
      _id: "$category",
      totalPrice: { $sum: "$price" },
      avgPrice: { $avg: "$price" },
      brands: { $addToSet: "$brand" }
    }
  },
  {
    $match: {
      totalPrice: { $gt: 500 },
      avgPrice: { $lt: 900 }
    }
  }
]);

Beispielausgabe

[
  {
    _id: 'Electronics',
    totalPrice: 1800,
    avgPrice: 900,
    brands: [ 'Apple', 'Samsung' ]
  }
]

Erläuterung der wichtigsten Aggregierungsoperatoren:

• $match: Filtert Dokumente basierend auf angegebenen Bedingungen
• $gt: Größer als
• $lt: Kleiner als
• $push: Fügt Elemente zu einem Array hinzu
• $addToSet: Fügt eindeutige Elemente zu einem Array hinzu

Sortieren von Gruppenergebnissen

In diesem letzten Schritt lernen Sie, wie Sie gruppierte Ergebnisse mit dem Aggregierungsframework von MongoDB sortieren. Das Sortieren hilft Ihnen, Ihre aggregierten Daten zu organisieren und zu priorisieren, was die Analyse und das Verständnis erleichtert.

Lassen Sie uns mit unserer salesdb-Datenbank fortfahren:

// Stellen Sie sicher, dass wir in der richtigen Datenbank sind
use salesdb

Wir werden die Produkte verwenden, die wir bereits erstellt haben, um Sortiertechniken zu demonstrieren:

1. Sortieren Sie Gruppen nach Gesamtpreis in absteigender Reihenfolge:

db.products.aggregate([
  {
    $group: {
      _id: "$category",
      totalPrice: { $sum: "$price" },
      productCount: { $sum: 1 }
    }
  },
  {
    $sort: {
      totalPrice: -1
    }
  }
]);

2. Sortieren Sie Gruppen nach Produktanzahl und Gesamtpreis:

db.products.aggregate([
  {
    $group: {
      _id: "$category",
      totalPrice: { $sum: "$price" },
      productCount: { $sum: 1 }
    }
  },
  {
    $sort: {
      productCount: -1,
      totalPrice: 1
    }
  }
]);

3. Fortgeschrittenes Sortieren mit mehreren Aggregationsstufen:

db.products.aggregate([
  {
    $group: {
      _id: "$category",
      totalPrice: { $sum: "$price" },
      avgPrice: { $avg: "$price" },
      brands: { $addToSet: "$brand" }
    }
  },
  {
    $project: {
      category: "$_id",
      totalPrice: 1,
      avgPrice: 1,
      brandCount: { $size: "$brands" }
    }
  },
  {
    $sort: {
      brandCount: -1,
      totalPrice: -1
    }
  }
]);

Beispielausgabe

[
  {
    category: 'Electronics',
    totalPrice: 1800,
    avgPrice: 900,
    brandCount: 2
  },
  {
    category: 'Clothing',
    totalPrice: 180,
    avgPrice: 90,
    brandCount: 2
  },
  {
    category: 'Books',
    totalPrice: 0,
    avgPrice: 0,
    brandCount: 2
  }
]

Erläuterung der wichtigsten Aggregierungsoperatoren:

• $sort: Sortiert die Dokumente
  • 1: Aufsteigende Reihenfolge
  • -1: Absteigende Reihenfolge
• $project: Formt die Dokumente um, sodass Sie Felder einbeziehen, ausschließen oder transformieren können
• $size: Zählt die Anzahl der Elemente in einem Array

Zusammenfassung

In diesem Lab werden Sie lernen, wie Sie MongoDB-Daten mit dem Aggregierungsframework gruppieren. Zunächst werden Sie die Daten nach einem einzelnen Feld gruppieren, wie beispielsweise der Produktkategorie, und die Gesamtpreise für jede Gruppe berechnen. Anschließend werden Sie fortgeschrittene Aggregierungsoperatoren erkunden, um Gruppensummen zu berechnen, einschließlich des Durchschnittspreises, der Anzahl der Elemente und das Filtern und Sortieren der gruppierten Ergebnisse. Diese Techniken sind essentiell für die Datenanalyse und das Gewinn von Erkenntnissen aus Ihren MongoDB-Daten.