स्ट्रिंग फ़ील्ड मान को उसके सबस्ट्रिंग में बदलने का सबसे कारगर तरीका

ऐसा करने का सबसे कारगर तरीका है MongoDB की आगामी रिलीज़ में इस लेखन के रूप में $split का उपयोग करना ऑपरेटर हमारे स्ट्रिंग को यहां दिखाया गया है के रूप में विभाजित करने के लिए फिर का उपयोग करके एक चर के लिए सरणी में अंतिम तत्व असाइन करें $लेट वेरिएबल ऑपरेटर और $arrayElemAt ऑपरेटरों।

इसके बाद, हम $switch . का उपयोग करते हैं ऑपरेटर उस चर के खिलाफ तार्किक स्थिति प्रसंस्करण या केस स्टेटमेंट करने के लिए।

यहां शर्त है $gt यदि मान में "test" . होता है, तो यह सच हो जाता है , और किस मामले में में अभिव्यक्ति हम उस स्ट्रिंग को विभाजित करते हैं और बस $concat नए कंप्यूटेड ऐरे में पहले एलिमेंट का एनेटेड वैल्यू और - . यदि कंडीशन का मूल्यांकन गलत होता है, तो हम केवल वेरिएबल को वापस कर देते हैं।

बेशक हमारे केस स्टेटमेंट में, हम $indexOfCP . का उपयोग करते हैं जो -1 . लौटाता है अगर "test" . की कोई घटना नहीं होती ।

let cursor = db.collection.aggregate(
    [
        { "$project": { 
            "data": 1, 
            "version": { 
                "$let": { 
                    "vars": { 
                        "v": { 
                            "$arrayElemAt": [
                                { "$split": [ "$version", "." ] }, 
                                -1
                            ]
                        }
                    }, 
                    "in": { 
                        "$switch": { 
                            "branches": [ 
                                { 
                                    "case": { 
                                        "$gt": [ 
                                            { "$indexOfCP": [ "$$v", "test" ] },
                                            -1 
                                        ]
                                    }, 
                                    "then": { 
                                        "$concat": [ 
                                            "-", 
                                            "", 
                                            { "$arrayElemAt": [
                                                { "$split": [ "$$v", "-" ] }, 
                                                0 
                                            ]} 
                                        ]
                                    }
                                }
                            ], 
                            "default": "$$v" 
                        }
                    }
                }
            }
        }}
    ]
)

एकत्रीकरण क्वेरी कुछ इस तरह उत्पन्न करती है:

{ "_id" : ObjectId("57a98773cbbd42a2156260d8"), "data" : 11, "version" : "32" }
{ "_id" : ObjectId("57a98773cbbd42a2156260d9"), "data" : 55, "version" : "-42" }

जैसा कि आप देख सकते हैं, "संस्करण" फ़ील्ड डेटा स्ट्रिंग हैं। यदि उस फ़ील्ड के लिए डेटा प्रकार कोई मायने नहीं रखता है, तो आप बस $out . का उपयोग कर सकते हैं परिणाम को एक नए संग्रह में लिखने या अपने संग्रह को बदलने के लिए एकत्रीकरण पाइपलाइन चरण ऑपरेटर।

{ "out": "collection" }

यदि आपको अपने डेटा को फ़्लोटिंग पॉइंट नंबर में कनवर्ट करने की आवश्यकता है, तो ऐसा करने का एकमात्र तरीका, केवल इसलिए कि MongoDB स्ट्रिंग से पूर्णांक को छोड़कर बॉक्स से बाहर टाइप रूपांतरण करने का कोई तरीका प्रदान नहीं करता है, एकत्रीकरण कर्सर को पुनरावृत्त करना है parseFloat या नंबर फिर $set का उपयोग करके अपने दस्तावेज़ अपडेट करें ऑपरेटर और bulkWrite() अधिकतम दक्षता के लिए विधि।

let requests = [];
cursor.forEach(doc => { 
    requests.push({ 
        "updateOne": { 
            "filter": { "_id": doc._id }, 
            "update": { 
                "$set": { 
                    "data": doc.data, 
                    "version": parseFloat(doc.version) 
                },
                "$unset": { "person": " " }
            } 
        } 
    }); 
    if ( requests.length === 1000 ) { 
        // Execute per 1000 ops and re-init
        db.collection.bulkWrite(requests); 
        requests = []; 
    }} 
);

 // Clean up queues
if(requests.length > 0) {
    db.coll.bulkWrite(requests);
}

जबकि एकत्रीकरण क्वेरी पूरी तरह से MongoDB 3.4 में काम करेगी या नई MongoDB 3.2 से हमारी सबसे अच्छी शर्त mapReduce bulkWrite() . के साथ विधि।

var results = db.collection.mapReduce(
    function() { 
        var v = this.version.split(".")[2]; 
        emit(this._id, v.indexOf("-") > -1 ? "-"+v.replace(/\D+/g, '') : v)
    }, 
    function(key, value) {}, 
    { "out": { "inline": 1 } }
)["results"];

परिणाम ऐसा दिखता है:

[
    {
        "_id" : ObjectId("57a98773cbbd42a2156260d8"),
        "value" : "32"
    },
    {
        "_id" : ObjectId("57a98773cbbd42a2156260d9"),
        "value" : "-42"
    }
]

यहाँ से आप पिछले का उपयोग करते हैं .प्रत्येक के लिए अपने दस्तावेज़ों को अपडेट करने के लिए लूप।

MongoDB 2.6 से 3.0 तक आपको अब बहिष्कृत बल्क ( ) मेरे यहां जवाब दें।