MongoDB में एकल फ़ील्ड में सरणी में स्ट्रिंग मानों को संयोजित करें

आधुनिक मोंगोडीबी रिलीज में आप कर सकते हैं। आप अभी भी $concat . पर किसी सरणी को "सीधे" लागू नहीं कर सकते हैं , हालांकि आप $reduce . का उपयोग कर सकते हैं सरणी तत्वों के साथ काम करने और इसे उत्पन्न करने के लिए:

db.collection.aggregate([
  { "$addFields": {
    "values": { 
      "$reduce": {
        "input": "$values",
        "initialValue": "",
        "in": {
          "$cond": {
            "if": { "$eq": [ { "$indexOfArray": [ "$values", "$$this" ] }, 0 ] },
            "then": { "$concat": [ "$$value", "$$this" ] },
            "else": { "$concat": [ "$$value", "_", "$$this" ] }
          }    
        }
      }        
    }
  }}
])

पाठ्यक्रम का संयोजन $indexOfArray . के साथ नहीं . करने के लिए "_" . के साथ "concatenate" अंडरस्कोर करें जब यह सरणी की "पहली" अनुक्रमणिका है।

साथ ही मेरी अतिरिक्त "इच्छा" का उत्तर $sum . के साथ दिया गया है :

db.collection.aggregate([
  { "$addFields": {
    "total": { "$sum": "$items.value" }
  }}
])

इस तरह के सामान की एक सरणी लेने वाले एकत्रीकरण ऑपरेटरों के साथ सामान्य रूप से थोड़ा सा उठाया जाता है। यहां अंतर यह है कि इसका अर्थ है वर्तमान दस्तावेज़ में मौजूद "सरणी तत्व" के विपरीत कोडित प्रतिनिधित्व में प्रदान किए गए "एगुमेंट्स" की "सरणी"।

जिस तरह से आप वास्तव में दस्तावेज़ में मौजूद एक सरणी के भीतर वस्तुओं के संयोजन को कर सकते हैं, वह है किसी प्रकार का जावास्क्रिप्ट विकल्प करना, जैसा कि इस उदाहरण के साथ mapReduce:

db.collection.mapReduce(
    function() {
        emit( this._id, { "values": this.values.join("_") } );
    },
    function() {},
    { "out": { "inline": 1 } }
)

बेशक यदि आप वास्तव में कुछ भी एकत्र नहीं कर रहे हैं, तो संभवतः सबसे अच्छा तरीका यह है कि आप अपने क्वेरी परिणामों को पोस्ट करने में अपने क्लाइंट कोड के भीतर "जॉइन" ऑपरेशन करें। लेकिन अगर इसे किसी दस्तावेज़ में किसी उद्देश्य में उपयोग करने की आवश्यकता है तो mapReduce एकमात्र ऐसा स्थान होगा जहां आप इसका उपयोग कर सकते हैं।

मैं जोड़ सकता हूं कि "उदाहरण के लिए" मैं इस तरह से काम करने के लिए कुछ पसंद करूंगा:

{
    "items": [
        { "product": "A", "value": 1 },
        { "product": "B", "value": 2 },
        { "product": "C", "value": 3 }
    ]
}

और कुल मिलाकर:

db.collection.aggregate([
    { "$project": {
        "total": { "$add": [
            { "$map": {
                "input": "$items",
                "as": "i",
                "in": "$$i.value"
            }}
        ]}
    }}
])

लेकिन यह उस तरह से काम नहीं करता क्योंकि $add दस्तावेज़ से एक सरणी के विपरीत तर्कों की अपेक्षा करता है। साँस! :(। इसके लिए "डिजाइन द्वारा" तर्क का हिस्सा तर्क दिया जा सकता है कि "सिर्फ इसलिए" यह परिवर्तन के परिणाम से पारित होने वाले एकवचन मूल्यों की एक सरणी या "सूची" है, यह "गारंटी" नहीं है कि वे हैं वास्तव में "वैध" एकवचन संख्यात्मक प्रकार मान जो ऑपरेटर की अपेक्षा करता है। कम से कम "टाइप चेकिंग" के वर्तमान कार्यान्वित तरीकों पर नहीं।

इसका मतलब है कि अभी के लिए हमें अभी भी यह करना है:

db.collection.aggregate([
   { "$unwind": "$items" },
   { "$group": {
       "_id": "$_id",
        "total": { "$sum": "$items.value" }
   }}
])

और यह भी दुख की बात है कि इस तरह के ग्रुपिंग ऑपरेटर को स्ट्रिंग्स को जोड़ने के लिए लागू करने का कोई तरीका नहीं होगा।

तो आप इस पर किसी प्रकार के बदलाव की उम्मीद कर सकते हैं, या कुछ बदलाव की उम्मीद कर सकते हैं जो एक बाहरी दायरे वाले चर को $map के दायरे में बदलने की अनुमति देता है। किसी तरह से संचालन। बेहतर अभी तक एक नया $join ऑपरेशन का भी स्वागत होगा। लेकिन ये लेखन के रूप में मौजूद नहीं हैं, और संभवत:आने वाले कुछ समय के लिए नहीं होंगे।