$लुकअप ऑपरेटर का उपयोग करके एकाधिक शामिल होने की शर्तें

हम $lookup . के साथ कई जॉइन कंडीशन कर सकते हैं संस्करण 3.6 और नए में एकत्रीकरण पाइपलाइन ऑपरेटर।

हमें let . का उपयोग करके फ़ील्ड के मानों को वेरिएबल में असाइन करने की आवश्यकता है वैकल्पिक क्षेत्र; फिर आप उन चरों को pipeline . में एक्सेस करते हैं फ़ील्ड चरण जहाँ आप संग्रह पर चलने के लिए पाइपलाइन निर्दिष्ट करते हैं।

ध्यान दें कि $match . में चरण, हम $expr . का उपयोग करते हैं फ़ील्ड के मान की तुलना करने के लिए मूल्यांकन क्वेरी ऑपरेटर।

पाइपलाइन में अंतिम चरण $replaceRoot . है एकत्रीकरण पाइपलाइन चरण जहां हम केवल $lookup . को मर्ज करते हैं $$ROOT . के भाग के साथ परिणाम $mergeObjects . का उपयोग कर दस्तावेज़ ऑपरेटर।

db.collection2.aggregate([
       {
          $lookup: {
             from: "collection1",
             let: {
                firstUser: "$user1",
                secondUser: "$user2"
             },
             pipeline: [
                {
                   $match: {
                      $expr: {
                         $and: [
                            {
                               $eq: [
                                  "$user1",
                                  "$$firstUser"
                               ]
                            },
                            {
                               $eq: [
                                  "$user2",
                                  "$$secondUser"
                               ]
                            }
                         ]
                      }
                   }
                }
             ],
             as: "result"
          }
       },
       {
          $replaceRoot: {
             newRoot: {
                $mergeObjects:[
                   {
                      $arrayElemAt: [
                         "$result",
                         0
                      ]
                   },
                   {
                      percent1: "$$ROOT.percent1"
                   }
                ]
             }
          }
       }
    ]
)

यह पाइपलाइन कुछ इस तरह दिखती है:

{
    "_id" : ObjectId("59e1ad7d36f42d8960c06022"),
    "user1" : 1,
    "user2" : 2,
    "percent" : 0.3,
    "percent1" : 0.56
}

यदि आप संस्करण 3.6+ पर नहीं हैं, तो आप पहले अपने किसी एक क्षेत्र का उपयोग करके "user1" कह सकते हैं, फिर वहां से आप $unwind का उपयोग करके मिलान करने वाले दस्तावेज़ की सरणी को खोल सकते हैं। एकत्रीकरण पाइपलाइन ऑपरेटर। पाइपलाइन में अगला चरण $redact . है चरण जहां आप उन दस्तावेज़ों को फ़िल्टर करते हैं जहाँ "शामिल" संग्रह से "user2" का मान और इनपुट दस्तावेज़ $$KEEP का उपयोग करके समान नहीं हैं और $$PRUNE सिस्टम चर। फिर आप अपने दस्तावेज़ को $project . में फिर से आकार दे सकते हैं मंच।

db.collection1.aggregate([
    { "$lookup": { 
        "from": "collection2", 
        "localField": "user1", 
        "foreignField": "user1", 
        "as": "collection2_doc"
    }}, 
    { "$unwind": "$collection2_doc" },
    { "$redact": { 
        "$cond": [
            { "$eq": [ "$user2", "$collection2_doc.user2" ] }, 
            "$$KEEP", 
            "$$PRUNE"
        ]
    }}, 
    { "$project": { 
        "user1": 1, 
        "user2": 1, 
        "percent1": "$percent", 
        "percent2": "$collection2_doc.percent"
    }}
])

जो उत्पादन करता है:

{
    "_id" : ObjectId("572daa87cc52a841bb292beb"),
    "user1" : 1,
    "user2" : 2,
    "percent1" : 0.56,
    "percent2" : 0.3
}

यदि आपके संग्रह के दस्तावेज़ों की संरचना समान है और आप स्वयं को अक्सर इस ऑपरेशन को करते हुए पाते हैं, तो आपको दो संग्रहों को एक में मर्ज करने पर विचार करना चाहिए या उन संग्रहों में दस्तावेज़ों को एक नए संग्रह में सम्मिलित करना चाहिए।

db.collection3.insertMany(
    db.collection1.find({}, {"_id": 0})
    .toArray()
    .concat(db.collection2.find({}, {"_id": 0}).toArray())
)

फिर $group "user1" और "user2" द्वारा आपके दस्तावेज़

db.collection3.aggregate([
    { "$group": {
        "_id": { "user1": "$user1", "user2": "$user2" }, 
        "percent": { "$push": "$percent" }
    }}
])

जो पैदावार:

{ "_id" : { "user1" : 1, "user2" : 2 }, "percent" : [ 0.56, 0.3 ] }