यहां आपका सबसे अच्छा विकल्प प्रत्येक "देश" (आदर्श रूप से समानांतर में) के लिए अलग-अलग प्रश्नों को चलाने और संयुक्त परिणाम वापस करना है। प्रश्न काफी सरल हैं, और रेटिंग मान पर एक प्रकार लागू करने के बाद केवल शीर्ष 2 मान लौटाएं और पूर्ण परिणाम प्राप्त करने के लिए आपको कई प्रश्नों को करने की आवश्यकता होने पर भी बहुत तेज़ी से निष्पादित होंगे।
एकत्रीकरण ढांचा इसके लिए अभी और निकट भविष्य में भी उपयुक्त नहीं है। समस्या यह है कि ऐसा कोई ऑपरेटर नहीं है जो किसी भी तरह से किसी भी समूह के परिणाम को "सीमित" करता है। तो ऐसा करने के लिए, आपको मूल रूप से $push . की आवश्यकता है एक सरणी में सभी सामग्री और उसमें से "शीर्ष n" मान निकालें।
ऐसा करने के लिए आवश्यक वर्तमान संचालन बहुत भयानक हैं, और मुख्य समस्या यह है कि परिणाम अधिकांश वास्तविक डेटा स्रोतों पर प्रति दस्तावेज़ 16 एमबी की बीएसओएन सीमा से अधिक होने की संभावना है।
इसके अलावा एक n है इसकी जटिलता के कारण आपको इसे अभी कैसे करना होगा। लेकिन सिर्फ 2 वस्तुओं के साथ प्रदर्शित करने के लिए:
db.collection.aggregate([
// Sort content by country and rating
{ "$sort": { "Country": 1, "rating": -1 } },
// Group by country and push all items, keeping first result
{ "$group": {
"_id": "$Country",
"results": {
"$push": {
"name": "$name",
"rating": "$rating",
"id": "$id"
}
},
"first": {
"$first": {
"name": "$name",
"rating": "$rating",
"id": "$id"
}
}
}},
// Unwind the array
{ "$unwind": "results" },
// Remove the seen result from the array
{ "$redact": {
"$cond": {
"if": { "$eq": [ "$results.id", "$first.id" ] },
"then": "$$PRUNE",
"else": "$$KEEP"
}
}},
// Group to return the second result which is now first on stack
{ "$group": {
"_id": "$_id",
"first": { "$first": "$first" },
"second": {
"$first": {
"name": "$results.name",
"rating": "$results.rating",
"id": "$results.id"
}
}
}},
// Optionally put these in an array format
{ "$project": {
"results": {
"$map": {
"input": ["A","B"],
"as": "el",
"in": {
"$cond": {
"if": { "$eq": [ "$$el", "A" ] },
"then": "$first",
"else": "$second"
}
}
}
}
}}
])
यह परिणाम प्राप्त करता है लेकिन यह एक महान दृष्टिकोण नहीं है और उच्च सीमा के लिए पुनरावृत्तियों के साथ बहुत अधिक जटिल हो जाता है या यहां तक कि जहां समूह संभवतः n से कम हैं कुछ मामलों में परिणाम वापस आ जाते हैं।
लेखन के रूप में वर्तमान विकास श्रृंखला (3.1.x) में एक $slice . है ऑपरेटर जो इसे थोड़ा और सरल बनाता है, लेकिन अभी भी वही "आकार" नुकसान है:
db.collection.aggregate([
// Sort content by country and rating
{ "$sort": { "Country": 1, "rating": -1 } },
// Group by country and push all items, keeping first result
{ "$group": {
"_id": "$Country",
"results": {
"$push": {
"name": "$name",
"rating": "$rating",
"id": "$id"
}
}
}},
{ "$project": {
"results": { "$slice": [ "$results", 2 ] }
}}
])
लेकिन मूल रूप से जब तक एकत्रीकरण ढांचे में $push द्वारा उत्पादित वस्तुओं की संख्या को "सीमित" करने का कोई तरीका नहीं है या एक समान समूहीकरण "सीमा" ऑपरेटर, तो एकत्रीकरण ढांचा वास्तव में इस प्रकार की समस्या का इष्टतम समाधान नहीं है।
इस तरह के सरल प्रश्न:
db.collection.find({ "Country": "USA" }).sort({ "rating": -1 }).limit(1)
प्रत्येक विशिष्ट देश के लिए चलाएं और आदर्श रूप से एक संयुक्त परिणाम के साथ थ्रेड के इवेंट लूप द्वारा समानांतर प्रसंस्करण में अभी सबसे इष्टतम दृष्टिकोण पैदा करता है। वे केवल वही प्राप्त करते हैं जिसकी आवश्यकता होती है, जो कि एक बड़ी समस्या है जिसे एकत्रीकरण ढांचा अभी तक इस तरह के समूह में नहीं संभाल सकता है।
इसलिए इस "संयुक्त क्वेरी परिणाम" को अपनी चुनी हुई भाषा के लिए सबसे इष्टतम तरीके से करने के लिए समर्थन की तलाश करें, क्योंकि यह एकत्रीकरण ढांचे पर इसे फेंकने की तुलना में बहुत कम जटिल और अधिक प्रदर्शनकारी होगा।
