Aggregation Pipeline

• Methode, um grosse Anzahl verschiedener Dokumente einer Collection zu bearbeiten und auszuwerten
• Bearbeitung und Auswertung verschiedener Dokumente einer Collection
• Aneinanderreihung/Durchlauf verschiedener Stages

MongoDB Docs - Aggregation Reference

Begriffe

Aggregation

• Analyse und Zusammenfassung von Daten

Stage

• Aggregation-Operation, ausgeführt auf den Daten

Aggregation Pipeline

• Ausführung mehrerer Stages geordnet hintereinander

Syntax

db.<collection>.aggregate(
    { <stage> }
)

db.<collection>.aggregate( [
    { <stage> },
    { <stage> },
    ...
] )

Operatoren

MongoDB Docs - Aggregation Operator

Stages

Stages/Einzeloperationen

• werden aneinandergereiht
• jede Stage bearbeitet die Output-Dokumente der letzten Stage
• Funktionen
  • Filterung
  • Sortierung
  • Gruppierung
    • es können Resultate für Gruppen berechnet werden: Anzahl, Summe, Durchschnitt, Minimum, Maximum
  • Bearbeitung

Stage	Beschreibung	Syntax
$match	Filterung	{ $match: { <query predicate> } }
$group	Gruppierung	{ $group: { _id: <expression>, <field1>: { <accumulator1> : <expression1> }, ... } }
$sort	Sortierung	{ $sort: { <field1>: <sort order>, <field2>: <sort order> ... } }
$project	Eigenschaften-Auswahl	{ $project: { <specification(s)> } }
$out	Speicherung in Collection in beliebiger Datenbank	{ $out: "<output-collection>" }
$unwind	Restrukturierung von Array-Elemente in einzelne Dokumente	{ $unwind: <field path> }

$match - Filterung

db.collection.aggregate( [
    {
        $match: {
            <query predicate>
        }
    }
] )

Beispiel:

db.collection.aggregate([
    $match: {
        $or: [
            { score: { $gt: 70, $lt: 90 } }, 
            { views: { $gte: 1000 } } 
        ] 
    }
]);

$group - Gruppierung

db.collection.aggregate([
    {
        $group: {
            _id: <expression>, // property to group with: "$fieldName"
            <field1>: { <accumulator1> : <expression1> },
            ...
        }
    }
])

	Bedeutung
<expression>	existierendes Feld, nach dem gruppiert wird: $fieldName
<field1>	neues Feld mit berechnetem Wert der Gruppe
<accumulator1>	Definierung, welche Berechnung auf Gruppe ausgeführt werden soll
<expression1>	Ausdruck für Berechnungs-Operator

Accumulator	Bedeutung
$avg	Durchschnitt
$bottom	letztes Element
$buttomN	letzte n Elemente
$count	Anzahl der Elemente
$first	Resultat von Expression des ersten Elements
$firstN	Resultat von Expression der ersten n Elemente
$last	Resultat von Expression des letzten Elements
$lastN	Resultat von Expression der letzten n Elemente
$max	grösster Wert einer Expression
$maxN	n grösste Werte
$median	Median
$mergeObjects	Erstellung von Dokument durch Kombinierung aller Elemente
$min	kleinster Wert einer Expression
$minN	n kleinste Werte
$sum	Summe
$top	erstes Element
$topN	erste n Elemente

Beispiel:

db.collection.aggregate([
  {
    $unwind: {
      path: "$module"
    }
  },
  {
    $unwind: {
      path: "$module.noten"
    }
  },
  {
    $group: {
      _id: "$schueler.id",
      schueler_name: {
        $first: "$schueler.name"
      },
      schueler_vorname: {
        $first: "$schueler.vorname"
      },
      noten_durchschnitt: {
        $avg: "$module.noten.note"
      }
    }
  }
])

$sort - Sortierung

db.collection.aggregate([
    {
        $sort: {
            <field1>: <sort order>,
            <field2>: <sort order>
            ... 
        }
    }
])

<sort order>:

Wert	Bedeutung
1	ascending
-1	descending

Beispiel:

db.shoes.aggregate( [
   {
      $match: { sizes: { $gt: 9 } }
   },
   {
      $sort: { sizes: 1 }
   }
] )

$limit - Limitierung

db.collection.aggregate( [
    { $limit: <positive 64-bit integer> }
] )

$project - Feld-Auswahl

Mit $project können Eigenschaften aus-, eingeblendet und hinzugefügt werden.

db.collection.aggregate( [
    {
        $project: {
            <specification(s)>
        }
    }
] )

Beispiel:

db.collection.aggregate( [
    {
        $project: {
           size: 1,
           _id: 0,
           name: { $toUpper: "$_id" }
        }
    }
] )

$set - Änderung und Hinzufügen von Feldern

db.zips.aggregate( [
    {
        $set: {
            <field1>: <expression1>,
            <field2>: <expression2>,
            ...
        }
    }
] )

Beispiel:

db.zips.aggregate( [
    {
        $set: {
            population_2022: {
                $round: {
                    $multiply: [
                        "$population_2021",
                        1.0031
                    ]
                }
            }
        }
    }
] )

$count - Anzahl Dokumente

Zählt die Anzahl der Dokumente, welche durch die Pipeline zurückgegeben werden und zeigt diesen Wert in einem Feld an.

db.collection.aggregate( [```
    {
        $count: "<output-field>"
    }
] )

$out - Speicherung in Collection in beliebiger Datenbank

Schreibt die Dokumente der Pipeline in eine neue Collection in der aktuellen oder einer beliebigen Datenbank. Existiert die zu erstellende Collection schon, wird sie überschrieben. MongoDB Docs - Time Series

db.collection.aggregate( [
    {
        $out: "<output-collection>" 
    }
] )

db.collection.aggregate( [
    {
        $out: {
            db: "<output-db>",
            coll: "<output-collection>"
        }
    }
] )

db.collection.aggregate( [
    {
        $out: {
            db: "<output-db>",
            coll: "<output-collection>",
            timeseries: {
                timeField: "<field-name>",
                metaField: "<field-name>",
                granularity:  "seconds" || "minutes" || "hours" ,
            }
        }
    }
] )

Time Series Collections speichern Daten, welche nach Zeit organisiert sind. Es werden die Werte der Daten an verschiedenen Zeitpunkten gespeichert.

Beispiel:

db.collection.aggregate( [
    {
        $out: {
            db: "analyses",
            coll: "books"
        }
    }
] )

$unwind - Restrukturierung von Array-Elemente in einzelne Dokumente

Mit $unwind werden alle Elemente eines bestimmten Arrays in ein einzelnes Dokument gepackt, wobei die anderen Eigenschaften in jedem so erstellten Dokument vorkommen.

db.collection.aggregate( [
    {
        $unwind: <field path>
    }
] )

db.collection.aggregate( [
    {
        $unwind: {
            path: <field path>,
            includeArrayIndex: <string>,
            preserveNullAndEmptyArrays: <boolean>
        }
    }
] )

Beispiel:

db.clothing.insertMany([
  { "_id" : 1, "item" : "Shirt", "sizes": [ "S", "M", "L"] },
  { "_id" : 2, "item" : "Shorts", "sizes" : [ ] },
  { "_id" : 3, "item" : "Hat", "sizes": "M" },
  { "_id" : 4, "item" : "Gloves" },
  { "_id" : 5, "item" : "Scarf", "sizes" : null }
])

db.clothing.aggregate( [
    {
        $unwind: {
            path: "$sizes"
        }
    }
] )

Ausgabe:

{ _id: 1, item: 'Shirt', sizes: 'S' },
{ _id: 1, item: 'Shirt', sizes: 'M' },
{ _id: 1, item: 'Shirt', sizes: 'L' },
{ _id: 3, item: 'Hat', sizes: 'M' }