Kombinieren Sie mit MongoDB zwei Sammlungen zu einer Sammlung

1. Kombinieren Sie mit MongoDB zwei Sammlungen zu einer Sammlung
2. Verwenden Sie die aggregierte Phase $lookup, um zwei Sammlungen zu einer zusammenzuführen
3. Verwenden Sie den pipeline-Operator, um zwei Sammlungen basierend auf der angegebenen Bedingung zu einer zu verbinden
4. Verwenden Sie den Operator $unwind, um das Array vor dem Anhängen an die resultierenden Dokumente zu glätten
5. Verwenden Sie die Filterphase $project in Aggregationsabfragen, um zwei Sammlungen zu einer zusammenzufügen
6. Verbinden Sie zwei Sammlungen mit Compass (grafische Oberfläche von MongoDB)

Heute werden wir die Aggregatphase $lookup, die Operatoren pipeline und $unwind, die Filterphase $project und MongoDB Compass verwenden, um zwei Sammlungen zu einer Sammlung zu kombinieren.

Kombinieren Sie mit MongoDB zwei Sammlungen zu einer Sammlung

Wir haben verschiedene Ansätze, um zwei Sammlungen mit MongoDB zu einer Sammlung zu kombinieren. Einige davon sind unten aufgeführt, die wir in diesem Tutorial behandeln werden.

1. Verwenden Sie die Aggregatstufe $lookup, um zwei Sammlungen zusammenzuführen
2. Verwenden Sie den pipeline-Operator, um zwei Sammlungen basierend auf der angegebenen Bedingung zusammenzuführen
3. Verwenden Sie den Operator $unwind, um ein Array zu glätten, bevor Sie es an die resultierenden Dokumente anhängen
4. Verwenden Sie die Filterstufe $project in Aggregationsabfragen, um zwei Sammlungen zusammenzuführen
5. Verbinden Sie zwei Sammlungen mit einem Kompass (einer grafischen Oberfläche von MongoDB)

Für alle oben genannten Szenarien benötigen wir eine Datenbank mit zwei Sammlungen (wie Tabellen in MySQL), die mit Dokumenten gefüllt sind (wie Datensätze in MySQL). Wir haben dies mit den folgenden Abfragen getan; das kannst du auch.

Erstellen Sie zwei Sammlungen namens usersInformation und userAddress, die sich in der Datenbank users befinden. Füllen Sie sie außerdem wie folgt mit Dokumenten.

Datenbank und Sammlungen erstellen:

> use users
> db.createCollection('userInformation')
> db.createCollection('userAddress')

Füllen Sie die Sammlung userInformation mit zwei Dokumenten:

> db.userInformation.insertMany(
    [
        {
            fullname: 'Mehvish Ashiq',
            age: 30,
            gender: 'Female',
            nationality: 'Pakistani'
        },
        {
            fullname: 'James Daniel',
            age: 45,
            sex: 'male',
            nationality: 'Canadian'
        }
    ]
)

Füllen Sie die Sammlung userAddress mit zwei Dokumenten:

> db.userAddress.insertMany(
    [
        {
            fullname: 'Mehvish Ashiq',
            block_number: 22,
            street: 'Johar Town Street',
            city: 'Lahore'
        },
        {
            fullname: 'James Daniel',
            block_number: 30,
            street: 'Saint-Denis Street',
            city: 'Montreal'
        }
    ]
)

Wir verwenden die Funktion insertMany(), um mehrere Dokumente einzufügen. Jetzt können wir die folgenden Befehle verwenden, um die Daten für beide Sammlungen anzuzeigen.

Im folgenden Codeausschnitt zeigt die Methode pretty() die saubere und formatierte Ausgabe, die auf der Shell leicht zu verstehen ist.

Dokumente aus der userInformation anzeigen:

> db.userInformation.find().pretty()

AUSGANG:

{
        "_id" : ObjectId("628bc4a45c544feccff5a566"),
        "fullname" : "Mehvish Ashiq",
        "age" : 30,
        "gender" : "Female",
        "nationality" : "Pakistani"
}
{
        "_id" : ObjectId("628bc4a45c544feccff5a567"),
        "fullname" : "James Daniel",
        "age" : 45,
        "sex" : "male",
        "nationality" : "Canadian"
}

Dokumente aus der userAddress anzeigen:

> db.userAddress.find().pretty()

AUSGANG:

{
        "_id" : ObjectId("628bc4ae5c544feccff5a568"),
        "fullname" : "Mehvish Ashiq",
        "block_number" : 22,
        "street" : "Johar Town Street",
        "city" : "Lahore"
}
{
        "_id" : ObjectId("628bc4ae5c544feccff5a569"),
        "fullname" : "James Daniel",
        "block_number" : 30,
        "street" : "Saint-Denis Street",
        "city" : "Montreal"
}

Beide Sammlungen müssen sich in derselben Datenbank befinden, um die Aggregatstufe $lookup zu verwenden. Sobald beide Sammlungen fertig sind, können wir die verschiedenen Abfragen verwenden, um die Daten beider Sammlungen zu verbinden, je nachdem, welches Szenario wir haben.

Verwenden Sie die aggregierte Phase $lookup, um zwei Sammlungen zu einer zusammenzuführen

Beispielcode:

> db.userInformation.aggregate([
    { $lookup:
        {
           from: 'userAddress',
           localField: 'fullname',
           foreignField: 'fullname',
           as: 'address'
        }
    }
]).pretty();

AUSGANG:

{
        "_id" : ObjectId("628bc4a45c544feccff5a566"),
        "fullname" : "Mehvish Ashiq",
        "age" : 30,
        "gender" : "Female",
        "nationality" : "Pakistani",
        "address" : [
                {
                        "_id" : ObjectId("628bc4ae5c544feccff5a568"),
                        "fullname" : "Mehvish Ashiq",
                        "block_number" : 22,
                        "street" : "Johar Town Street",
                        "city" : "Lahore"
                }
        ]
}
{
        "_id" : ObjectId("628bc4a45c544feccff5a567"),
        "fullname" : "James Daniel",
        "age" : 45,
        "sex" : "male",
        "nationality" : "Canadian",
        "address" : [
                {
                        "_id" : ObjectId("628bc4ae5c544feccff5a569"),
                        "fullname" : "James Daniel",
                        "block_number" : 30,
                        "street" : "Saint-Denis Street",
                        "city" : "Montreal"
                }
        ]
}

In der MongoDB-Datenbank führt die $lookup aggregate stage den Left Outer Join mit der anderen Sammlung durch und filtert auch Informationen (Daten) aus den verbundenen Dokumenten. Beispielsweise verwenden wir die Abfrage, um die Informationen aller Benutzer mit ihren Adressen zu erhalten.

Die Funktion $lookup akzeptiert vier Felder. Das erste ist das von-Feld, in dem wir die Sammlung angeben, die mit der anderen Sammlung verbunden werden soll.

Das zweite ist das Feld localField. Es ist eines der Attribute (Feld) aus den Eingabedokumenten der Sammlung, die im Feld von angegeben sind.

Es wird verwendet, um einen Abgleich zwischen localField und foreignField aus den Dokumenten der Sammlungen durchzuführen.

In ähnlicher Weise führt das dritte Feld mit dem Namen foreignField auch den Gleichheitsabgleich zwischen foreignField und localField aus den Dokumenten der Sammlungen durch.

Wir schreiben den Namen des neuen Arrays für das vierte Feld as. Siehe folgende Erläuterung zur Aggregatstufe $lookup.

Verwenden Sie den pipeline-Operator, um zwei Sammlungen basierend auf der angegebenen Bedingung zu einer zu verbinden

Beispielcode:

> db.userInformation.aggregate([{
    $lookup:{
        from: 'userAddress',
        let: {full_name: '$fullname'},
        pipeline: [{
            $match: {
                $expr: {
                    $eq: ['$fullname', '$$full_name']
                }
             }
       }],
       as: 'addressInfo'
    }
}]).pretty()

AUSGANG:

{
        "_id" : ObjectId("628bc4a45c544feccff5a566"),
        "fullname" : "Mehvish Ashiq",
        "age" : 30,
        "gender" : "Female",
        "nationality" : "Pakistani",
        "addressInfo" : [
                {
                        "_id" : ObjectId("628bc4ae5c544feccff5a568"),
                        "fullname" : "Mehvish Ashiq",
                        "block_number" : 22,
                        "street" : "Johar Town Street",
                        "city" : "Lahore"
                }
        ]
}
{
        "_id" : ObjectId("628bc4a45c544feccff5a567"),
        "fullname" : "James Daniel",
        "age" : 45,
        "sex" : "male",
        "nationality" : "Canadian",
        "addressInfo" : [
                {
                        "_id" : ObjectId("628bc4ae5c544feccff5a569"),
                        "fullname" : "James Daniel",
                        "block_number" : 30,
                        "street" : "Saint-Denis Street",
                        "city" : "Montreal"
                }
        ]
}

Wir können den pipeline-Operator mit $lookup verwenden, wenn wir zwei Sammlungen basierend auf einer bestimmten Bedingung verbinden möchten (genau wie wir die WHERE-Klausel in MySQL verwenden).

Zum Beispiel schließen wir uns den Sammlungen an, bei denen der vollständige Name von userAddress gleich dem vollständigen Namen in userInformation ist.

Verwenden Sie den Operator $unwind, um das Array vor dem Anhängen an die resultierenden Dokumente zu glätten

Beispielcode:

> db.userInformation.aggregate([
    { $lookup:
        {
           from: 'userAddress',
           localField: 'fullname',
           foreignField: 'fullname',
           as: 'address'
        }
    },
    {
       $unwind: '$address'
    }
]).pretty();

AUSGANG:

{
        "_id" : ObjectId("628bc4a45c544feccff5a566"),
        "fullname" : "Mehvish Ashiq",
        "age" : 30,
        "gender" : "Female",
        "nationality" : "Pakistani",
        "address" : {
                "_id" : ObjectId("628bc4ae5c544feccff5a568"),
                "fullname" : "Mehvish Ashiq",
                "block_number" : 22,
                "street" : "Johar Town Street",
                "city" : "Lahore"
        }
}
{
        "_id" : ObjectId("628bc4a45c544feccff5a567"),
        "fullname" : "James Daniel",
        "age" : 45,
        "sex" : "male",
        "nationality" : "Canadian",
        "address" : {
                "_id" : ObjectId("628bc4ae5c544feccff5a569"),
                "fullname" : "James Daniel",
                "block_number" : 30,
                "street" : "Saint-Denis Street",
                "city" : "Montreal"
        }
}

Der Operator $unwind tut nichts anderes, als das Array zu glätten, bevor es an das resultierende Dokument angehängt wird. Der grundlegende Unterschied zum Operator $unwind besteht darin, dass er ein Array mit einem einzelnen Element in das abgeflachte Objekt, das Element selbst, umwandelt.

Denken Sie daran, dass der Name für dieses Element nicht geändert wird. Es wäre dasselbe wie zuvor, wenn das Element in Form eines Arrays vorliegt.

Führen Sie die obige Abfrage mit und ohne den Operator $unwind aus und beobachten Sie das Feld Adresse.

Verwenden Sie die Filterphase $project in Aggregationsabfragen, um zwei Sammlungen zu einer zusammenzufügen

Bevor wir uns den Sammlungen mit dem $project anschließen, wollen wir seine Bedeutung verstehen. Wenn wir zum Beispiel nicht die ganze Sammlung mit dem Namen userAddress mit userInformation verbinden wollen, wollen wir nur die Felder city und street verbinden.

In diesem Fall müssen wir die Stufe $addFields verwenden. Wir verwenden diese Phase, um ein beliebiges Feld oder mehrere Felder aus einem Array/Objekt der Stammebene des Dokuments hinzuzufügen/zuzuordnen.

Wir führen also die folgende Abfrage aus, um Stadt und Straße aus der Sammlung Benutzeradresse abzurufen.

Beispielcode:

> db.userInformation.aggregate([
    { $lookup:
        {
           from: 'userAddress',
           localField: 'fullname',
           foreignField: 'fullname',
           as: 'address'
        }
    },
    {
       $unwind: '$address'
    },
    {
       $addFields: {
           street: '$address.street',
           city: '$address.city'
       }
    }
]).pretty();

AUSGANG:

{
        "_id" : ObjectId("628bc4a45c544feccff5a566"),
        "fullname" : "Mehvish Ashiq",
        "age" : 30,
        "gender" : "Female",
        "nationality" : "Pakistani",
        "address" : {
                "_id" : ObjectId("628bc4ae5c544feccff5a568"),
                "fullname" : "Mehvish Ashiq",
                "block_number" : 22,
                "street" : "Johar Town Street",
                "city" : "Lahore"
        },
        "street" : "Johar Town Street",
        "city" : "Lahore"
}
{
        "_id" : ObjectId("628bc4a45c544feccff5a567"),
        "fullname" : "James Daniel",
        "age" : 45,
        "sex" : "male",
        "nationality" : "Canadian",
        "address" : {
                "_id" : ObjectId("628bc4ae5c544feccff5a569"),
                "fullname" : "James Daniel",
                "block_number" : 30,
                "street" : "Saint-Denis Street",
                "city" : "Montreal"
        },
        "street" : "Saint-Denis Street",
        "city" : "Montreal"
}

Konzentrieren Sie sich sorgfältig auf die oben angegebene Ausgabe. Bekommen wir Straße und Stadt? Ja, wir bekommen die street und city auf der Root-Ebene des Dokuments, aber wir haben auch das address-Objekt, das wir jetzt nicht brauchen.

Hier kommt die Filterstufe $project ins Spiel. Es gibt an, welche Felder wir im resultierenden Dokument haben sollten.

Sehen Sie sich zum besseren Verständnis die folgende Abfrage an.

Beispielcode:

> db.userInformation.aggregate([
    { $lookup:
        {
           from: 'userAddress',
           localField: 'fullname',
           foreignField: 'fullname',
           as: 'address'
        }
    },
    {
       $unwind: '$address'
    },
    {
       $addFields: {
           street: '$address.street',
           city: '$address.city'
       }
    },
    {
       $project: {
           fullname: 1,
           age: 1,
           gender: 1,
           street: 1,
           city: 1
       }
    }
]).pretty();

AUSGANG:

{
        "_id" : ObjectId("628bc4a45c544feccff5a566"),
        "fullname" : "Mehvish Ashiq",
        "age" : 30,
        "gender" : "Female",
        "street" : "Johar Town Street",
        "city" : "Lahore"
}
{
        "_id" : ObjectId("628bc4a45c544feccff5a567"),
        "fullname" : "James Daniel",
        "age" : 45,
        "street" : "Saint-Denis Street",
        "city" : "Montreal"
}

Wie Sie sehen, haben wir das Objekt address jetzt nicht, aber seine beiden Felder (street und city) sind der Stammebene des Dokuments zugeordnet.

Verbinden Sie zwei Sammlungen mit Compass (grafische Oberfläche von MongoDB)

Die Aggregation über eine grafische Oberfläche ist einfach. Wir müssen nur die folgenden Schritte für die Aggregationsstufe $lookup ausführen.

1. Öffnen Sie MongoDBCompass und verbinden Sie sich mit dem Server.

2. Erstellen Sie eine brandneue Datenbank und zwei Sammlungen, wenn Sie möchten. Wir verwenden dieselbe Datenbank und Sammlungen, die wir mit einer Mongo-Shell erstellt haben.

3. Öffnen Sie Ihre Sammlungen, die wie folgt aussehen.

   

4. Fügen Sie die Phase gemäß Ihren Projektanforderungen hinzu; wir fügen die Aggregationsstufe $lookup hinzu. Aktualisieren Sie die $lookup-Felder und sehen Sie die gewünschten Ergebnisse auf der rechten Seite.