MongoDb :एक क्वेरी के भीतर दो सरणियों से सामान्य तत्व खोजें

आप जो चाहते हैं उसे करने के लिए कुछ दृष्टिकोण हैं, यह सिर्फ मोंगोडीबी के आपके संस्करण पर निर्भर करता है। बस खोल प्रतिक्रिया सबमिट कर रहा है। सामग्री मूल रूप से JSON प्रतिनिधित्व है जो जावा में DBObject संस्थाओं के लिए अनुवाद करना कठिन नहीं है, या जावास्क्रिप्ट को सर्वर पर निष्पादित किया जाना है ताकि वास्तव में परिवर्तन न हो।

पहला और सबसे तेज़ तरीका MongoDB 2.6 और इससे बड़ा है जहाँ आपको नए सेट ऑपरेशन मिलते हैं:

var test = [ "t3", "t4", "t5" ];

db.collection.aggregate([
   { "$match": { "tags": {"$in": test } }},
   { "$project": {
       "tagMatch": {
           "$setIntersection": [
               "$tags",
               test
           ]
       },
       "sizeMatch": {
           "$size": {
               "$setIntersection": [
                   "$tags",
                   test
               ]
           }
       }
   }},
   { "$match": { "sizeMatch": { "$gte": 1 } } },
   { "$project": { "tagMatch": 1 } }
])

नए ऑपरेटर हैं $setIntersection जो मुख्य काम कर रहा है और $ आकार ऑपरेटर जो सरणी आकार को मापता है और बाद वाले फ़िल्टरिंग के लिए मदद करता है। यह प्रतिच्छेद करने वाली वस्तुओं को खोजने के लिए "सेट" की एक बुनियादी तुलना के रूप में समाप्त होता है।

यदि आपके पास मोंगोडीबी का पुराना संस्करण है तो यह अभी भी संभव है, लेकिन आपको कुछ और चरणों की आवश्यकता है और यदि आपके पास बड़े सरणी हैं तो यह कुछ हद तक प्रदर्शन को प्रभावित कर सकता है:

var test = [ "t3", "t4", "t5" ];

db.collection.aggregate([
   { "$match": { "tags": {"$in": test } }},
   { "$project": {
      "tags": 1,
      "match": { "$const": test }
   }},
   { "$unwind": "$tags" },
   { "$unwind": "$match" },
   { "$project": {
       "tags": 1,
       "matched": { "$eq": [ "$tags", "$match" ] }
   }},
   { "$match": { "matched": true }},
   { "$group": {
       "_id": "$_id",
       "tagMatch": { "$push": "$tags" },
       "count": { "$sum": 1 }
   }}
   { "$match": { "count": { "$gte": 1 } }},
   { "$project": { "tagMatch": 1 }}
])

या यदि यह सब शामिल लगता है या प्रदर्शन में अंतर लाने के लिए आपकी सरणियाँ काफी बड़ी हैं तो हमेशा mapReduce :

var test = [ "t3", "t4", "t5" ];

db.collection.mapReduce(
    function () {
      var intersection = this.tags.filter(function(x){
          return ( test.indexOf( x ) != -1 );
      });
      if ( intersection.length > 0 ) 
          emit ( this._id, intersection );
   },
   function(){},
   {
       "query": { "tags": { "$in": test } },
       "scope": { "test": test },
       "output": { "inline": 1 }
   }
)

ध्यान दें कि सभी मामलों में $in कोड> ऑपरेटर अभी भी आपको परिणामों को कम करने में मदद करता है, भले ही यह पूर्ण मिलान न हो। दूसरा सामान्य तत्व प्रतिक्रिया को कम करने के लिए प्रतिच्छेदन परिणाम के "आकार" की जाँच कर रहा है।