MongoDB 2.1 में नया एकत्रीकरण ढांचा

2.1 जारी करने में, नए डेटा एकत्रीकरण ढांचे के रूप में ऐसी कार्यक्षमता के कार्यान्वयन की घोषणा की गई थी । मैं इस सबसे दिलचस्प बात के पहले छापों के बारे में बात करना चाहूंगा। इस कार्यक्षमता को कुछ स्थानों में मैप / रिड्यूस को त्यागने की अनुमति देनी चाहिए और लगभग SQL में समूह फ़ील्ड के लिए डिज़ाइन किए गए काफी सरल निर्माणों के पक्ष में जावास्क्रिप्ट कोड लिखना चाहिए।



नवाचारों पर प्रलेखन आधिकारिक वेबसाइट के संबंधित अनुभाग में स्थित है। सबसे पहले, आइए देखें कि यह कैसे काम करता है और कौन से MongoDB निर्माण हमारी मदद करेंगे।

तो, MongoDB से डेटा लाने में मुख्य कठिनाई कुछ अलग तत्वों के अंदर निहित सरणियों और डेटा के साथ काम कर रही है। हाँ, हम उन्हें एसक्यूएल के रूप में चुन सकते हैं, लेकिन हम सीधे लाने पर उन्हें एकत्र नहीं कर सकते। नया फ्रेमवर्क ऐसे डेटा के साथ काम करने का एक घोषणात्मक तरीका है, जो विशेष ऑपरेटरों की एक श्रृंखला पर आधारित है (उनमें से केवल 7 हैं)। नमूना डेटा को एक ऑपरेटर के आउटपुट से दूसरे के इनपुट में स्थानांतरित किया जाता है, जैसे यूनिक्स में। नए ऑपरेटरों की मदद से, आप मौजूदा लोगों को दोहरा सकते हैं। लोगों के बारे में डेटा संग्रहीत करने के लिए परीक्षण संग्रह को एक संग्रह होने दें। मानक नमूना:

db.test.find({name: "Ivan"}); 

समान होगा

 db.test.aggregate({$match: {name: "Ivan"}}); 

लेकिन सब थोड़ा और दिलचस्प है, क्योंकि दूसरे उदाहरण में हम एक अल्पविराम के साथ ऑपरेटरों को सूचीबद्ध करके डेटा प्रोसेसिंग चेन बना सकते हैं। $ सॉर्ट ऑपरेटर को सॉर्ट करने के लिए उपयोग किया जाता है, उदाहरण के लिए:

 db.test.aggregate({$match: {name: "Ivan"}}, {$sort: {age: 1}}); 

तो हम "इवान" नाम के साथ सभी लोगों को वेब करते हैं और उम्र के अनुसार नमूने को सॉर्ट करते हैं। और सबसे पुराना इवान चुनने के लिए, हमें एक तत्व के साथ चयन में कटौती करने की आवश्यकता है:

 db.test.aggregate({$match: {name: "Ivan"}}, {$sort: {age: -1}}, {$limit: 1}); 

आप कहेंगे कि यह मौजूदा क्रियाशीलता का दोहराव है। कुछ हद तक, हाँ, लेकिन हमने नए ऑपरेटरों पर विचार नहीं किया है जो नमूनों के साथ अधिक लचीला काम करने की अनुमति देते हैं। हम उन्हें और अधिक विस्तार से विश्लेषण करेंगे।

ऑपरेटर $ परियोजना

फ़ील्ड में हेरफेर करने के लिए डिज़ाइन किया गया, नए लोगों को जोड़ सकता है, हटा सकता है और उनके इनपुट पर प्राप्त दस्तावेजों में उनका नाम बदल सकता है। निम्नलिखित निर्माण में दस्तावेज़ प्रवाह (केवल उपयोगकर्ताओं के नाम और आयु) को शामिल करना शामिल होगा:

 {$project: {name: 1, age: 1}} 

केवल दो फ़ील्ड वाले सभी दस्तावेज़ अगले ऑपरेटर के इनपुट को मिलेंगे, धारा में कोई अन्य फ़ील्ड नहीं होगा (सिवाय _id फ़ील्ड के, इसे बाहर करने के लिए, आपको _id: 0 निर्दिष्ट करना होगा)। नंबर 1 में शामिल है, नंबर 0 क्षेत्र के प्रसारण को बाहर करता है। इसके अलावा, यह ऑपरेटर आपको फ़ील्ड्स का नाम बदलने की अनुमति देता है, फ़ील्ड के एम्बेडेड ऑब्जेक्ट से फ़ील्ड्स को "प्राप्त" करें या अपनी गणना के आधार पर नए फ़ील्ड जोड़ें।

$ खोल ऑपरेटर

मेरी राय में, यह सबसे दिलचस्प ऑपरेटर है। यह आपको दस्तावेजों के चयन के प्रत्येक तत्व के लिए नेस्टेड सरणियों का "विस्तार" करने की अनुमति देता है। उदाहरण के लिए, हम लोगों के निम्नलिखित आधार हैं:

 db.test.insert({name: "Ivan", likes: ["Maria", "Anna"]}); db.test.insert({name: "Serge", likes: ["Anna"]}); 

लाइक फील्ड का मतलब है कि कौन सी लड़की को कौन सा लड़का पसंद है। $ खोल ऑपरेटर लागू करें:

 db.test.aggregate({$unwind: "$likes"}); 

 { "result" : [ { "_id" : ObjectId("4f598de76a8f8bc74573e9fd"), "name" : "Ivan", "likes" : "Maria" }, { "_id" : ObjectId("4f598de76a8f8bc74573e9fd"), "name" : "Ivan", "likes" : "Anna" }, { "_id" : ObjectId("4f598e086a8f8bc74573e9fe"), "name" : "Serge", "likes" : "Anna" } ], "ok" : 1 } 

हम देखते हैं कि पसंद सरणी का विस्तार हुआ है और प्रत्येक दस्तावेज़ में अब प्रत्येक सरणी मान के साथ एक पसंद फ़ील्ड है जो पहले था। यदि हम सबसे लोकप्रिय लड़की को ढूंढना चाहते हैं, तो चयन क्षेत्र को पसंद करें। समूह के लिए, निम्न ऑपरेटर का उपयोग करें।

$ समूह ऑपरेटर

सुविधा के लिए, हम नंबर 1 से भरे एक अन्य क्षेत्र के साथ चयन को पूरक करते हैं (यह इस तरह संक्षेप में आसान होगा):

 db.test.aggregate({$unwind: "$likes"}, {$project: {name:1, likes:1, count: {$add: [1]}}}); 

 { "result" : [ { "_id" : ObjectId("4f598de76a8f8bc74573e9fd"), "name" : "Ivan", "likes" : "Maria", "count" : 1 }, { "_id" : ObjectId("4f598de76a8f8bc74573e9fd"), "name" : "Ivan", "likes" : "Anna", "count" : 1 }, { "_id" : ObjectId("4f598e086a8f8bc74573e9fe"), "name" : "Serge", "likes" : "Anna", "count" : 1 } ], "ok" : 1 } 

यह हमें $ योग एकत्रीकरण ऑपरेटर का उपयोग करने की अनुमति देगा। यही है, अब हम हर बार संख्या फ़ील्ड में गिनती फ़ील्ड के मान को जोड़ते हैं और लड़की के नाम वाले पसंद फ़ील्ड द्वारा पूरे नमूने को समूहित करते हैं।

 db.test.aggregate({$unwind: "$likes"}, {$project: {name:1, likes:1, count: {$add: [1]}}}, {$group: {_id: "$likes", number: {$sum: "$count"}}}); 

 { "result" : [ { "_id" : "Anna", "number" : 2 }, { "_id" : "Maria", "number" : 1 } ], "ok" : 1 } 

यह आउटपुट को केवल एक दस्तावेज़ तक क्रमबद्ध और सीमित करने के लिए रहता है:

 db.test.aggregate({$unwind: "$likes"}, {$project: {name:1, likes:1, count: {$add: [1]}}}, {$group: {_id: "$likes", number: {$sum: "$count"}}}, {$sort: {number: -1}}, {$limit: 1}); 

 { "result" : [ { "_id" : "Anna", "number" : 2 } ], "ok" : 1 } 

हमारी सबसे लोकप्रिय लड़की अन्ना है।

और अब एक ठोस उदाहरण है।

विशुद्ध रूप से विशेष रूप से नए अवसरों के साथ प्रवेश करने के लिए, मान लें कि हमारे पास एक संग्रह है जो चिड़ियाघर में जानवरों के बारे में डेटा संग्रहीत करता है और डेटा एकत्रीकरण की कई समस्याओं को हल करता है। यहाँ हमारे पंजे और पूंछ हैं:

 db.zoo.insert({name: "Lion", ration: [{meat: 20}, {fish: 1}, {water: 30}], holidays: [1,4], staff: {like: ["Petrovich", "Mihalich"], dislike: "Maria"}}); db.zoo.insert({name: "Tiger", ration: [{meat: 15}, {water: 25}], holidays: [6], staff: {like: ["Petrovich", "Maria"]}}); db.zoo.insert({name: "Monkey", ration: [{banana: 15}, {water: 10}, {nuts: 1}], holidays: [2], staff: {like: ["Anna"], dislike: "Petrovich"}}); db.zoo.insert({name: "Panda", ration: [{bamboo: 15}, {dumplings: 50}, {water: 3}], staff: {like: ["Petrovich", "Mihalich", "Maria", "Anna"]}}); 

नाम फ़ील्ड नाम को संग्रहीत करता है, राशन फ़ील्ड वस्तुओं का एक सरणी है जिसमें संग्रहीत किया जाता है कि जानवर को हर दिन कितना और किस तरह का भोजन चाहिए, छुट्टियां वे दिन हैं, जिस दिन जानवर आराम करता है और आगंतुकों को नहीं दिखाया जाता है, स्टाफ। वैसे ही वे करियर निर्माता हैं जो उन्हें पसंद करते हैं (पांडा, आकर्षक, प्यार सबसे अधिक ), staff.dislike - पसंद नहीं है।

आइए एक सरल चयन से शुरू करें - बस जानवरों के नाम, ताकि चिड़ियाघर के निदेशक यह न भूलें कि किसे कहा जाता है। यहाँ सब कुछ सरल है:

 db.zoo.aggregate({$project: {name: 1}}); 

 { "result" : [ { "_id" : ObjectId("4f58b7f627f86b11258dc70c"), "name" : "Lion" }, { "_id" : ObjectId("4f58b86027f86b11258dc70d"), "name" : "Tiger" }, { "_id" : ObjectId("4f58b90c27f86b11258dc70e"), "name" : "Monkey" }, { "_id" : ObjectId("4f58b98727f86b11258dc70f"), "name" : "Panda" } ], "ok" : 1 } 

आपको किस तरह के जानवरों की जरूरत है?

शिकारियों से डरना जरूरी है। एक शिकारी वह होता है जिसके आहार में मांस होता है। चलो उन्हें ढूंढते हैं। सबसे पहले, हम स्ट्रीम को फ़िल्टर करते हैं और दस्तावेजों में केवल दो फ़ील्ड चुनते हैं - नाम और राशन।

 db.zoo.aggregate({$project: {name: 1, _id: 0, ration: 1}}); 

 { "result" : [ { "name" : "Lion", "ration" : [ { "meat" : 20 }, { "fish" : 1 }, { "water" : 30 } ] }, { "name" : "Tiger", "ration" : [ { "meat" : 15 }, { "water" : 25 } ] }, { "name" : "Monkey", "ration" : [ { "banana" : 15 }, { "water" : 10 }, { "nuts" : 1 } ] }, { "name" : "Panda", "ration" : [ { "bamboo" : 15 }, { "dumplings" : 50 }, { "water" : 3 } ] } ], "ok" : 1 } 

फिर मुख्य सरणी के तत्वों के लिए राशन सरणी का विस्तार करें:

 db.zoo.aggregate({$project: {name: 1, _id: 0, ration: 1}}, {$unwind: "$ration"}); 

 { "result" : [ { "name" : "Lion", "ration" : { "meat" : 20 } }, { "name" : "Lion", "ration" : { "fish" : 1 } }, { "name" : "Lion", "ration" : { "water" : 30 } }, { "name" : "Tiger", "ration" : { "meat" : 15 } }, { "name" : "Tiger", "ration" : { "water" : 25 } }, { "name" : "Monkey", "ration" : { "banana" : 15 } }, { "name" : "Monkey", "ration" : { "water" : 10 } }, { "name" : "Monkey", "ration" : { "nuts" : 1 } }, { "name" : "Panda", "ration" : { "bamboo" : 15 } }, { "name" : "Panda", "ration" : { "dumplings" : 50 } }, { "name" : "Panda", "ration" : { "water" : 3 } } ], "ok" : 1 } 

इसके बाद, हम केवल उन फ़ील्ड्स के लिए चयन को फ़िल्टर करते हैं जहाँ पर राशन फ़ील्ड है

 db.zoo.aggregate({$project: {name: 1, _id: 0, ration: 1}}, {$unwind: "$ration"}, {$match: {"ration.meat": {$exists: true}}}); 

 { "result" : [ { "name" : "Lion", "ration" : { "meat" : 20 } }, { "name" : "Tiger", "ration" : { "meat" : 15 } } ], "ok" : 1 } 

और अंतिम निष्कर्ष केवल शिकारी का नाम है

 db.zoo.aggregate({$project: {name: 1, _id: 0, ration: 1}}, {$unwind: "$ration"}, {$match: {"ration.meat": {$exists: true}}}, {$project: {name: 1, _id: 0}}); 

 { "result" : [ { "name" : "Lion" }, { "name" : "Tiger" } ], "ok" : 1 } 

क्या दिन कम से कम एक जानवर आराम करता है

ऐसा करने के लिए, छुट्टियों को "स्तरीकृत" करें जानवरों की पूरी सरणी में सरणी (पांडा, हमेशा की तरह, सभी के लिए सुलभ है और हमेशा)।

 db.zoo.aggregate({$project: {name: 1, holidays: 1}}, {$unwind: "$holidays"}); 

 { "result" : [ { "_id" : ObjectId("4f58b7f627f86b11258dc70c"), "name" : "Lion", "holidays" : 1 }, { "_id" : ObjectId("4f58b7f627f86b11258dc70c"), "name" : "Lion", "holidays" : 4 }, { "_id" : ObjectId("4f58b86027f86b11258dc70d"), "name" : "Tiger", "holidays" : 6 }, { "_id" : ObjectId("4f58b90c27f86b11258dc70e"), "name" : "Monkey", "holidays" : 2 }, { "_id" : ObjectId("4f58b98727f86b11258dc70f"), "name" : "Panda" } ], "ok" : 1 } 

और हम केवल उन लोगों को फ़िल्टर करते हैं, जहां छुट्टियों का क्षेत्र -1 से अधिक संख्या है (अच्छी तरह से, या 0, जिनके लिए यह अधिक सुविधाजनक है)

 db.zoo.aggregate({$project: {name: 1, holidays: 1}}, {$unwind: "$holidays"},{$match: {holidays : {$gt: -1}}}); 

 { "result" : [ { "_id" : ObjectId("4f58b7f627f86b11258dc70c"), "name" : "Lion", "holidays" : 1 }, { "_id" : ObjectId("4f58b7f627f86b11258dc70c"), "name" : "Lion", "holidays" : 4 }, { "_id" : ObjectId("4f58b86027f86b11258dc70d"), "name" : "Tiger", "holidays" : 6 }, { "_id" : ObjectId("4f58b90c27f86b11258dc70e"), "name" : "Monkey", "holidays" : 2 } ], "ok" : 1 } 

हम सभी अनावश्यक हटा देते हैं।

 db.zoo.aggregate({$project: {name: 1, holidays: 1}}, {$unwind: "$holidays"},{$match: {holidays : {$gt: -1}}}, {$project: {holidays: 1, _id: 0}}); 

 { "result" : [ { "holidays" : 1 }, { "holidays" : 4 }, { "holidays" : 6 }, { "holidays" : 2 } ], "ok" : 1 } 

प्रति दिन कितने उत्पादों को खरीदने की आवश्यकता है।

सबसे दिलचस्प, मेरी राय में, कार्य। इसे लागू करने के लिए, याद रखें कि $ परियोजना खेतों का निर्माण कर सकती है और मांस संपत्ति के मूल्य के साथ एक मांस क्षेत्र बना सकती है।

 db.zoo.aggregate({$project: {ration: 1, _id: 0}}, {$unwind: "$ration"}, {$project: {ration: 1, meat: "$ration.meat", _id: 0}}); 

यदि यह फ़ील्ड पशु के आहार के गुणों में नहीं है, तो यह नहीं बनाया जाएगा। यहाँ एक नमूना भाग का एक उदाहरण दिया गया है:

 { "result" : [ { "ration" : { "meat" : 20 }, "meat" : 20 }, { "ration" : { "fish" : 1 } }, { "ration" : { "water" : 30 } }, ... } 

हम सभी प्रकार के भोजन के लिए ऐसा करते हैं और राशन वस्तु का उत्पादन स्वयं निकाल देते हैं:

 db.zoo.aggregate({$project: {ration: 1}}, {$unwind: "$ration"}, {$project: {ration: 0, _id: 0, meat: "$ration.meat", fish: "$ration.fish", water: "$ration.water", banana: "$ration.banana", bamboo: "$ration.bamboo", nuts: "$ration.nuts", dumplings: "$ration.dumplings", _id: 0}}); 

परिणामस्वरूप हम प्राप्त करते हैं

 { "result" : [ { "_id" : ObjectId("4f58e58227f86b11258dc713"), "meat" : 20 }, { "_id" : ObjectId("4f58e58227f86b11258dc713"), "fish" : 1 }, { "_id" : ObjectId("4f58e58227f86b11258dc713"), "water" : 30 }, { "_id" : ObjectId("4f58e5e127f86b11258dc714"), "meat" : 15 }, { "_id" : ObjectId("4f58e5e127f86b11258dc714"), "water" : 25 }, { "_id" : ObjectId("4f58e60027f86b11258dc715"), "banana" : 15 }, { "_id" : ObjectId("4f58e60027f86b11258dc715"), "water" : 10 }, { "_id" : ObjectId("4f58e60027f86b11258dc715"), "nuts" : 1 }, { "_id" : ObjectId("4f58e64a27f86b11258dc716"), "bamboo" : 15 }, { "_id" : ObjectId("4f58e64a27f86b11258dc716"), "dumplings" : 50 }, { "_id" : ObjectId("4f58e64a27f86b11258dc716"), "water" : 3 } ], "ok" : 1 } 

यह केवल $ समूह फ़ंक्शन का उपयोग करके इस पूरी चीज़ को जोड़ने / समूह करने के लिए बनी हुई है। समूह में _id फ़ील्ड का संकेत यहां अनिवार्य है, लेकिन हमें मूल रूप से इसकी आवश्यकता नहीं है, इसलिए इसे किसी प्रकार की बकवास करने दें। प्रत्येक प्रकार के भोजन के लिए, प्रत्येक जानवर के अलग-अलग आहार को संक्षेप में रखने के लिए एक उपयुक्त क्षेत्र बनाएं:

 db.zoo.aggregate({$project: {ration: 1}}, {$unwind: "$ration"}, {$project: {ration: 0, _id: 0, meat: "$ration.meat", fish: "$ration.fish", water: "$ration.water", banana: "$ration.banana", bamboo: "$ration.bamboo", nuts: "$ration.nuts", dumplings: "$ration.dumplings"}}, {$group: {_id: "s", sum_meat: {$sum: "$meat"}, sum_fish: {$sum: "$fish"}, sum_water: {$sum: "$water"}, sum_banana: {$sum: "$banana"}, sum_nuts: {$sum: "$nuts"}, sum_bamboo: {$sum: "$bamboo"}, sum_dumplings: {$sum: "$dumplings"}}}); 

 { "result" : [ { "_id" : "s", "sum_meat" : 35, "sum_fish" : 1, "sum_water" : 68, "sum_banana" : 15, "sum_nuts" : 1, "sum_bamboo" : 15, "sum_dumplings" : 50 } ], "ok" : 1 } 

पसंदीदा केयरटेकर

खेतों से फ़िल्टर करें और कर्मचारी को खोल दें।

 db.zoo.aggregate({$project: {name: 1, _id: 0, "staff.like": 1}}, {$unwind: "$staff.like"}); 

हमें याद है कि $ परियोजना क्षेत्र को एक स्तर ऊपर उठा सकती है:

 db.zoo.aggregate({$project: {name: 1, _id: 0, "staff.like": 1}}, {$unwind: "$staff.like"}, {$project: {_id: 0, name: "$staff.like"}}); 

इसलिए हमने सभी देखभालकर्ताओं का चयन किया, जो कम से कम किसी को पसंद करते हैं और कोई दो जानवरों को पसंद करता है, तो वह दो बार नमूने में मौजूद है।

 { "result" : [ { "name" : "Petrovich" }, { "name" : "Mihalich" }, { "name" : "Petrovich" }, { "name" : "Maria" }, { "name" : "Anna" }, { "name" : "Petrovich" }, { "name" : "Mihalich" }, { "name" : "Maria" }, { "name" : "Anna" } ], "ok" : 1 } 

अब आपको इन क्षेत्रों को योग करने की आवश्यकता है। लेकिन ऐसा करना इतना आसान नहीं है, क्योंकि हमारे पास संक्षेप के लिए कोई फ़ील्ड नहीं है, इसलिए हम इस फ़ील्ड को पहले से ज्ञात चिप के साथ बनाते हैं।

 db.zoo.aggregate({$project: {name: 1, _id: 0, "staff.like": 1}}, {$unwind: "$staff.like"}, {$project: {_id: 0, name: "$staff.like", count: {$add: [1]}}}); 

परिणामस्वरूप, मूल्य 1 के साथ एक और गणना फ़ील्ड प्रत्येक ऑब्जेक्ट में जोड़ा जाएगा। समूह और सारांशित करें:

 db.zoo.aggregate({$project: {name: 1, _id: 0, "staff.like": 1}}, {$unwind: "$staff.like"}, {$project: {_id: 0, name: "$staff.like", count: {$add: [1]}}}, {$group: {_id: "$name", num: {$sum: "$count"}}}); 

क्रमबद्ध करें और बहुत पहले तत्व को आउटपुट सीमित करें

 db.zoo.aggregate({$project: {name: 1, _id: 0, "staff.like": 1}}, {$unwind: "$staff.like"}, {$project: {_id: 0, name: "$staff.like", count: {$add: [1]}}}, {$group: {_id: "$name", num: {$sum: "$count"}}}, {$sort: {num: -1}}, {$limit: 1}); 

और हमें निम्नलिखित मिलते हैं:

 { "result" : [ { "_id" : "Petrovich", "num" : 3 } ], "ok" : 1 } 

बस इतना ही। रुचि रखने वालों के लिए, इस विषय पर अंग्रेजी में दो सरल रिपोर्ट हैं: एक और दो ।

सच कहूँ तो, मैं वास्तव में MongoDB पसंद करता हूं, हालांकि हमने इसे डेटा को अलग करने के लिए परियोजना के एक हिस्से पर ही इस्तेमाल किया था। वही मैप / रिड्यूस मेरे लिए हमेशा कुछ डरावना और असंगत रहा है, लेकिन डेटा एकत्रीकरण की नई चीज आपको आंशिक रूप से जावास्क्रिप्ट को बाहर करने की अनुमति देती है, क्योंकि किसी तरह इसकी व्याख्या की जाती है, और इसलिए धीमी गति से और इसे तैयार किए गए, और इसलिए तेजी से, भाषा तत्वों के साथ बदलें ।

PS यह ध्यान देने योग्य है कि संस्करण 2.1 अभी भी काफी कच्चा है। मुझे लगातार सभी तरह के अपवादों की पुष्टि हुई। लेकिन मुझे लगता है कि 2.2 में यह आखिरकार स्थिर और ठंडा होगा।