Verwendung von die Pipeline im Suchoperator in MongoDB

1. Was ist die Aggregationspipeline
2. Was ist der $lookup-Operator in MongoDB
3. Verwenden Sie die Pipeline im $lookup-Operator, um Bedingungen in MongoDB zu verbinden

In diesem Tutorial erfahren Sie, wie Sie die Pipeline im Operator lookup in MongoDB verwenden. Bevor Sie fortfahren, müssen Sie über ausreichende Kenntnisse über die Aggregationspipeline und den Operator $lookup verfügen, um die Verwendung der Pipeline im Operator $lookup bei der Verwendung von MongoDB zu verstehen.

Wenn Sie diese Konzepte bereits kennen, können Sie schnell zu den letzten beiden Codebeispielen dieses Tutorials wechseln.

Was ist die Aggregationspipeline

Es ist ein Verfahren zum Sammeln von Daten und Zurückgeben der berechneten Ergebnisse. Dieser Prozess sammelt Daten aus verschiedenen Dokumenten, gruppiert sie nach festgelegten Bedingungen und führt verschiedene Arten von Operationen an den gruppierten Daten durch.

Zum Beispiel Durchschnitt, Summe, Maximum und Minimum. Es ist genau wie bei den SQL-Aggregationsfunktionen.

In MongoDB können wir die Aggregation auf die folgenden drei Arten verwenden.

1. Aggregationspipeline – enthält verschiedene Stufen zur Transformation der bereitgestellten Dokumente. Jede Stufe akzeptiert den Satz von Dokumenten und erzeugt einen weiteren Satz von resultierenden Dokumenten, die weiter an die nächste Stufe weitergegeben werden, und dieser Prozess wird bis zur letzten Stufe fortgesetzt.

2. Map-Reduce-Funktion – Wir verwenden diese Funktion, um Ergebnisse in großem Maßstab zu aggregieren. Es hat zwei Funktionen, map und reduce.

   Die Methode map gruppiert alle Dokumente, während die Methode reduce Operationen an gruppierten Daten durchführt.

3. Single-Purpose-Aggregation – die einfachste Form der Aggregation, die zur Durchführung von Aggregationsaufgaben verwendet wird, ihr fehlen jedoch einige Funktionen im Vergleich zur Aggregations-Pipeline-Methode. Wir verwenden diese Art der Aggregation, um Aufgaben in einem bestimmten Dokument auszuführen, z. B. um die unterschiedlichen Werte in einem oder mehreren bestimmten Dokument(en) zu zählen.

Sie können auch dies lesen, um tiefer einzutauchen und Aggregationspipelines kennenzulernen.

Was ist der $lookup-Operator in MongoDB

Dieser Operator wird verwendet, um Left Outer Join auszuführen, um Daten von einem Dokument mit einem anderen innerhalb derselben Datenbank zusammenzuführen. Es filtert die Dokumente aus einer zusammengeführten Sammlung zur weiteren Verarbeitung.

Wir können diesen Operator auch verwenden, um einem bestehenden Dokument ein zusätzliches Feld hinzuzufügen.

Der Operator $lookup fügt ein neues Array-Attribut (Feld) hinzu, dessen Werte (Elemente) mit Dokumenten aus der verbundenen Sammlung übereinstimmen. Dann werden diese transformierten Dokumente an die nächste Stufe übergeben.

Der Operator $lookup hat drei verschiedene Syntaxen, die wir unter Berücksichtigung der Projektanforderungen verwenden können. Dieses Tutorial verwendet die $lookup-Syntax für Join-Bedingungen und Unterabfragen für die verbundene Sammlung.

Um mit einem Beispielcode zu üben, bereiten wir die Beispielsammlungen mit Daten vor.

Beispielcode:

db.createCollection('collection1');
db.createCollection('collection2');

db.collection1.insertMany([
    {"shopId": "001", "shopPosId": "001", "description": "description for 001"},
    {"shopId": "002", "description": "description for 002"},
    {"shopId": "003", "shopPosId": "003", "description": "description for 003"},
    {"shopId": "004", "description": "description for 004"}
]);

db.collection2.insertMany([
    {"shopId": "001", "shopPosId": "0078", "clientUid": "474192"},
    {"shopId": "002", "shopPosId": "0012", "clientUid": "474193"},
    {"shopId": "003", "shopPosId": "0034", "clientUid": "474194"},
    {"shopId": "004", "shopPosId": "0056", "clientUid": "474195"}
]);

Jetzt können wir die folgenden Befehle ausführen, um die eingefügten Dokumente in jeder Sammlung anzuzeigen.

db.collection1.find();
db.collection2.find();

Verwenden Sie die Pipeline im $lookup-Operator, um Bedingungen in MongoDB zu verbinden

Um zu lernen, wie man die Pipeline im Operator $lookup verwendet, verbinden wir Dokumente aus zwei Sammlungen, bei denen collection1.shopId gleich collection2.shopId ist und collection1 das Feld shopPosId nicht enthält .

Es werden nur solche Dokumente aus beiden Sammlungen zusammengefügt, die beide Bedingungen erfüllen. Siehe den unten angegebenen Beispielcode.

Beispielcode:

db.collection2.aggregate([
    {
        "$lookup": {
        "from": "collection1",
        "let": { "shopId": "$shopId" },
        "pipeline": [{
            "$match": {
                "$and": [
                    {"$expr": {"$eq": ['$shopId', '$$shopId'] }},
                    { "shopPosId": { "$exists": false } }
                ]
            }
         }],
         "as": "shopDescription"
        }
    }
]).pretty();

Ausgabe:

Haben Sie die oben angegebene Ausgabe sorgfältig beobachtet? Es werden nur die Dokumente aus beiden Sammlungen zusammengeführt, die beide Bedingungen in der Pipeline erfüllen (die collection1.shopId ist gleich der collection2.shopId, und die collection1 enthält das Feld shopPosId nicht).

Außerdem haben die Dokumente, die diese Bedingungen nicht erfüllen, ein leeres Array namens shopDescription (siehe die roten Kästchen in den obigen Ergebnissen). Wir können nur die resultierenden Dokumente anzeigen, die ein nicht leeres shopDescription-Array enthalten (siehe folgende Abfrage).

Beispielcode:

db.collection2.aggregate([
    {
        "$lookup": {
        "from": "collection1",
        "let": { "shopId": "$shopId" },
        "pipeline": [{
            "$match": {
                "$and": [
                    {"$expr": {"$eq": ['$shopId', '$$shopId'] }},
                    { "shopPosId": { "$exists": false } }
                ]
            }
         }],
         "as": "shopDescription"
        }
    },
    {
        "$match":{
            "shopDescription": { $exists: true, $not: {$size: 0} }
         }
    }
]).pretty();

Ausgabe: