Wie führe ich den SQL-Join in MongoDB aus?

Question

Wie führe ich den SQL-Join in MongoDB aus?

Nehmen wir an, Sie haben zwei Sammlungen (Benutzer und Kommentare), und ich möchte alle Kommentare mit pid=444 zusammen mit den Benutzerinformationen für jeden abrufen.

comments
  { uid:12345, pid:444, comment="blah" }
  { uid:12345, pid:888, comment="asdf" }
  { uid:99999, pid:444, comment="qwer" }

users
  { uid:12345, name:"john" }
  { uid:99999, name:"mia"  }

Gibt es eine Möglichkeit, alle Kommentare mit einem bestimmten Feld (z. B. ...find({pid:444}) ) und die mit jedem Kommentar verknüpften Benutzerinformationen in einem Rutsch zu finden?

Im Moment erhalte ich zuerst die Kommentare, die meinen Kriterien entsprechen, dann finde ich alle uid's in diesem Ergebnissatz heraus, erhalte die Benutzerobjekte und führe sie mit den Ergebnissen des Kommentars zusammen. Es scheint, dass ich das falsch mache.

Answer 1

Ab Mongo 3.2 sind die Antworten auf diese Frage meist nicht mehr korrekt. Der neue $lookup-Operator, der der Aggregationspipeline hinzugefügt wurde, ist im Wesentlichen identisch mit einem Left Outer Join:

https://docs.mongodb.org/master/reference/operator/aggregation/lookup/#pipe._S_lookup

Aus den Unterlagen:

{
   $lookup:
     {
       from: <collection to join>,
       localField: <field from the input documents>,
       foreignField: <field from the documents of the "from" collection>,
       as: <output array field>
     }
}

Natürlich ist Mongo no eine relationale Datenbank, und die Entwickler sind vorsichtig, spezifische Anwendungsfälle für $lookup zu empfehlen, aber zumindest ab 3.2 ist Join jetzt mit MongoDB möglich.

Answer 2

Wir können alle Daten innerhalb einer einzigen Sammlung mit einer einfachen Funktion in wenigen Zeilen über die Mongodb-Client-Konsole zusammenführen, und jetzt könnten wir in der Lage sein, die gewünschte Abfrage durchzuführen. Nachfolgend ein vollständiges Beispiel,

Die Autoren:

db.authors.insert([
    {
        _id: 'a1',
        name: { first: 'orlando', last: 'becerra' },
        age: 27
    },
    {
        _id: 'a2',
        name: { first: 'mayra', last: 'sanchez' },
        age: 21
    }
]);

Kategorien:

db.categories.insert([
    {
        _id: 'c1',
        name: 'sci-fi'
    },
    {
        _id: 'c2',
        name: 'romance'
    }
]);

Bücher

db.books.insert([
    {
        _id: 'b1',
        name: 'Groovy Book',
        category: 'c1',
        authors: ['a1']
    },
    {
        _id: 'b2',
        name: 'Java Book',
        category: 'c2',
        authors: ['a1','a2']
    },
]);

Buchverleih

db.lendings.insert([
    {
        _id: 'l1',
        book: 'b1',
        date: new Date('01/01/11'),
        lendingBy: 'jose'
    },
    {
        _id: 'l2',
        book: 'b1',
        date: new Date('02/02/12'),
        lendingBy: 'maria'
    }
]);

Die Magie:

db.books.find().forEach(
    function (newBook) {
        newBook.category = db.categories.findOne( { "_id": newBook.category } );
        newBook.lendings = db.lendings.find( { "book": newBook._id  } ).toArray();
        newBook.authors = db.authors.find( { "_id": { $in: newBook.authors }  } ).toArray();
        db.booksReloaded.insert(newBook);
    }
);

Abrufen der neuen Erfassungsdaten:

db.booksReloaded.find().pretty()

.- Antwort :)

{
    "_id" : "b1",
    "name" : "Groovy Book",
    "category" : {
        "_id" : "c1",
        "name" : "sci-fi"
    },
    "authors" : [
        {
            "_id" : "a1",
            "name" : {
                "first" : "orlando",
                "last" : "becerra"
            },
            "age" : 27
        }
    ],
    "lendings" : [
        {
            "_id" : "l1",
            "book" : "b1",
            "date" : ISODate("2011-01-01T00:00:00Z"),
            "lendingBy" : "jose"
        },
        {
            "_id" : "l2",
            "book" : "b1",
            "date" : ISODate("2012-02-02T00:00:00Z"),
            "lendingBy" : "maria"
        }
    ]
}
{
    "_id" : "b2",
    "name" : "Java Book",
    "category" : {
        "_id" : "c2",
        "name" : "romance"
    },
    "authors" : [
        {
            "_id" : "a1",
            "name" : {
                "first" : "orlando",
                "last" : "becerra"
            },
            "age" : 27
        },
        {
            "_id" : "a2",
            "name" : {
                "first" : "mayra",
                "last" : "sanchez"
            },
            "age" : 21
        }
    ],
    "lendings" : [ ]
}

Ich hoffe, diese Zeilen können Ihnen helfen.

Answer 3

Diese Seite auf der offiziellen mongodb-Website behandelt genau diese Frage:

https://mongodb-documentation.readthedocs.io/en/latest/ecosystem/tutorial/model-data-for-ruby-on-rails.html

Wenn wir unsere Liste der Beiträge anzeigen, müssen wir den Namen des Nutzers anzeigen, der den Beitrag veröffentlicht hat. Wenn wir eine relationale Datenbank verwenden würden, könnten wir eine Verknüpfung von Benutzern und Geschäften durchführen und alle unsere Objekte in einer einzigen Abfrage abrufen. MongoDB unterstützt jedoch keine Verknüpfungen und erfordert daher manchmal eine kleine Denormalisierung. In diesem Fall bedeutet dies, dass das Attribut "username" zwischengespeichert wird.

Beziehungspuristen fühlen sich vielleicht schon unwohl, als ob wir gegen ein universelles Gesetz verstoßen würden. Wir sollten jedoch bedenken, dass MongoDB-Sammlungen nicht mit relationalen Tabellen gleichzusetzen sind; jede dient einem anderen Zweck. Eine normalisierte Tabelle bietet einen atomaren, isolierten Datenblock. Ein Dokument hingegen repräsentiert eher ein Objekt als Ganzes. Im Falle einer sozialen Nachrichtenseite kann man argumentieren, dass ein Benutzername ein wesentlicher Bestandteil der geposteten Geschichte ist.

Answer 4

Mit der richtigen Kombination aus $Nachschlag , $Projekt y $match können Sie mehrere Tabellen über mehrere Parameter verbinden. Dies liegt daran, dass sie mehrfach verkettet werden können.

Angenommen, wir wollen folgendes tun ( Referenz )

SELECT S.* FROM LeftTable S
LEFT JOIN RightTable R ON S.ID = R.ID AND S.MID = R.MID  
WHERE R.TIM > 0 AND S.MOB IS NOT NULL

Schritt 1: Verknüpfung aller Tabellen

können Sie mit $lookup so viele Tabellen durchsuchen, wie Sie wollen.

$Nachschlag - eine für jede Tabelle in der Abfrage

$unwind - Daten korrekt denormalisiert, sonst wären sie in Arrays verpackt

Python-Code.

db.LeftTable.aggregate([
                        # connect all tables

                        {"$lookup": {
                          "from": "RightTable",
                          "localField": "ID",
                          "foreignField": "ID",
                          "as": "R"
                        }},
                        {"$unwind": "R"}

                        ])

Schritt 2: Definieren Sie alle Konditionalitäten

$Projekt : Definieren Sie hier alle bedingten Anweisungen und alle Variablen, die Sie auswählen möchten.

Python Code..

db.LeftTable.aggregate([
                        # connect all tables

                        {"$lookup": {
                          "from": "RightTable",
                          "localField": "ID",
                          "foreignField": "ID",
                          "as": "R"
                        }},
                        {"$unwind": "R"},

                        # define conditionals + variables

                        {"$project": {
                          "midEq": {"$eq": ["$MID", "$R.MID"]},
                          "ID": 1, "MOB": 1, "MID": 1
                        }}
                        ])

Schritt 3: Verbinden Sie alle Konditionalitäten

$match - alle Bedingungen mit OR oder AND usw. verbinden. Es kann mehrere dieser Bedingungen geben.

$Projekt : alle Bedingungen aufheben

Vollständiger Python-Code.

db.LeftTable.aggregate([
                        # connect all tables

                        {"$lookup": {
                          "from": "RightTable",
                          "localField": "ID",
                          "foreignField": "ID",
                          "as": "R"
                        }},
                        {"$unwind": "$R"},

                        # define conditionals + variables

                        {"$project": {
                          "midEq": {"$eq": ["$MID", "$R.MID"]},
                          "ID": 1, "MOB": 1, "MID": 1
                        }},

                        # join all conditionals

                        {"$match": {
                          "$and": [
                            {"R.TIM": {"$gt": 0}}, 
                            {"MOB": {"$exists": True}},
                            {"midEq": {"$eq": True}}
                        ]}},

                        # undefine conditionals

                        {"$project": {
                          "midEq": 0
                        }}

                        ])

So gut wie jede Kombination von Tabellen, Konditionalen und Joins kann auf diese Weise durchgeführt werden.

Answer 5

Sie müssen es so machen, wie Sie es beschrieben haben. MongoDB ist eine nicht-relationale Datenbank und unterstützt keine Joins.