TLDR सारांश
आधुनिक MongoDB रिलीज़ में आप इसे $sliceमूल एकत्रीकरण परिणाम से दूर कर सकते हैं । "बड़ी" परिणामों के लिए, प्रत्येक समूह के लिए बजाय समानांतर क्वेरी चला (एक प्रदर्शन लिस्टिंग जवाब के अंत में है), या के लिए प्रतीक्षा सर्वर 9377 संकल्प करने के लिए है, जो करने के लिए आइटम्स की संख्या के लिए एक "सीमा" की अनुमति होगी $pushएक को सरणी।
db.books.aggregate([
{ "$group": {
"_id": {
"addr": "$addr",
"book": "$book"
},
"bookCount": { "$sum": 1 }
}},
{ "$group": {
"_id": "$_id.addr",
"books": {
"$push": {
"book": "$_id.book",
"count": "$bookCount"
},
},
"count": { "$sum": "$bookCount" }
}},
{ "$sort": { "count": -1 } },
{ "$limit": 2 },
{ "$project": {
"books": { "$slice": [ "$books", 2 ] },
"count": 1
}}
])
MongoDB 3.6 पूर्वावलोकन
फिर भी हल करने नहीं सर्वर-9377 है, लेकिन इस रिलीज में $lookupएक नया "गैर सहसंबद्ध" विकल्प है जो एक लेता है की अनुमति देता है "pipeline"के बजाय एक तर्क के रूप अभिव्यक्ति "localFields"और "foreignFields"विकल्प। इसके बाद एक और पाइपलाइन अभिव्यक्ति के साथ "सेल्फ-ज्वाइन" की अनुमति देता है, जिसमें हम $limit"टॉप-एन" परिणाम वापस करने के लिए आवेदन कर सकते हैं ।
db.books.aggregate([
{ "$group": {
"_id": "$addr",
"count": { "$sum": 1 }
}},
{ "$sort": { "count": -1 } },
{ "$limit": 2 },
{ "$lookup": {
"from": "books",
"let": {
"addr": "$_id"
},
"pipeline": [
{ "$match": {
"$expr": { "$eq": [ "$addr", "$$addr"] }
}},
{ "$group": {
"_id": "$book",
"count": { "$sum": 1 }
}},
{ "$sort": { "count": -1 } },
{ "$limit": 2 }
],
"as": "books"
}}
])
अन्य जोड़ निश्चित रूप से "ज्वाइन" में मिलान वाले आइटमों का चयन करने के लिए चर $exprका उपयोग करके प्रक्षेपित करने की क्षमता है $match, लेकिन सामान्य आधार एक "पाइपलाइन के भीतर पाइपलाइन" है जहां आंतरिक सामग्री को माता-पिता से मेल द्वारा फ़िल्टर किया जा सकता है । चूंकि वे दोनों "पाइपलाइन" स्वयं हैं इसलिए हम $limitप्रत्येक परिणाम को अलग-अलग कर सकते हैं ।
यह समानांतर प्रश्नों को चलाने के लिए अगला सबसे अच्छा विकल्प होगा, और वास्तव में बेहतर होगा यदि $matchअनुमति दी गई और "उप-पाइपलाइन" प्रसंस्करण में एक सूचकांक का उपयोग करने में सक्षम हो। इसलिए जो "सीमा" का उपयोग नहीं करता है $pushजैसा कि संदर्भित मुद्दा पूछता है, यह वास्तव में कुछ ऐसा काम करता है जो बेहतर काम करना चाहिए।
मूल सामग्री
आपको लगता है कि शीर्ष "एन" समस्या पर ठोकर खाई है। एक तरह से आपकी समस्या को हल करना काफी आसान है, हालांकि उस सटीक सीमा के साथ नहीं जो आप पूछते हैं:
db.books.aggregate([
{ "$group": {
"_id": {
"addr": "$addr",
"book": "$book"
},
"bookCount": { "$sum": 1 }
}},
{ "$group": {
"_id": "$_id.addr",
"books": {
"$push": {
"book": "$_id.book",
"count": "$bookCount"
},
},
"count": { "$sum": "$bookCount" }
}},
{ "$sort": { "count": -1 } },
{ "$limit": 2 }
])
अब जो आपको इस तरह से परिणाम देगा:
{
"result" : [
{
"_id" : "address1",
"books" : [
{
"book" : "book4",
"count" : 1
},
{
"book" : "book5",
"count" : 1
},
{
"book" : "book1",
"count" : 3
}
],
"count" : 5
},
{
"_id" : "address2",
"books" : [
{
"book" : "book5",
"count" : 1
},
{
"book" : "book1",
"count" : 2
}
],
"count" : 3
}
],
"ok" : 1
}
तो यह इस बात से भिन्न है कि आप उसमें क्या पूछ रहे हैं, जबकि हम पते के लिए शीर्ष परिणाम प्राप्त करते हैं अंतर्निहित "किताबें" चयन केवल आवश्यक परिणामों की मात्रा तक सीमित नहीं है।
यह करने के लिए बहुत मुश्किल हो जाता है, लेकिन यह किया जा सकता है हालांकि जटिलता सिर्फ उन वस्तुओं की संख्या के साथ बढ़ती है जिन्हें आपको मिलान करने की आवश्यकता है। इसे सरल रखने के लिए हम इसे 2 मैचों में अधिक से अधिक रख सकते हैं:
db.books.aggregate([
{ "$group": {
"_id": {
"addr": "$addr",
"book": "$book"
},
"bookCount": { "$sum": 1 }
}},
{ "$group": {
"_id": "$_id.addr",
"books": {
"$push": {
"book": "$_id.book",
"count": "$bookCount"
},
},
"count": { "$sum": "$bookCount" }
}},
{ "$sort": { "count": -1 } },
{ "$limit": 2 },
{ "$unwind": "$books" },
{ "$sort": { "count": 1, "books.count": -1 } },
{ "$group": {
"_id": "$_id",
"books": { "$push": "$books" },
"count": { "$first": "$count" }
}},
{ "$project": {
"_id": {
"_id": "$_id",
"books": "$books",
"count": "$count"
},
"newBooks": "$books"
}},
{ "$unwind": "$newBooks" },
{ "$group": {
"_id": "$_id",
"num1": { "$first": "$newBooks" }
}},
{ "$project": {
"_id": "$_id",
"newBooks": "$_id.books",
"num1": 1
}},
{ "$unwind": "$newBooks" },
{ "$project": {
"_id": "$_id",
"num1": 1,
"newBooks": 1,
"seen": { "$eq": [
"$num1",
"$newBooks"
]}
}},
{ "$match": { "seen": false } },
{ "$group":{
"_id": "$_id._id",
"num1": { "$first": "$num1" },
"num2": { "$first": "$newBooks" },
"count": { "$first": "$_id.count" }
}},
{ "$project": {
"num1": 1,
"num2": 1,
"count": 1,
"type": { "$cond": [ 1, [true,false],0 ] }
}},
{ "$unwind": "$type" },
{ "$project": {
"books": { "$cond": [
"$type",
"$num1",
"$num2"
]},
"count": 1
}},
{ "$group": {
"_id": "$_id",
"count": { "$first": "$count" },
"books": { "$push": "$books" }
}},
{ "$sort": { "count": -1 } }
])
तो यह वास्तव में आपको शीर्ष दो "पता" प्रविष्टियों से शीर्ष 2 "पुस्तकें" देगा।
लेकिन मेरे पैसे के लिए, पहले फॉर्म के साथ रहें और फिर बस "स्लाइस" एरे के तत्वों को पहले "ए" तत्वों को लेने के लिए वापस कर दें।
प्रदर्शन कोड
प्रदर्शन कोड v8.x और v10.x रिलीज़ से NodeJS के वर्तमान LTS संस्करणों के उपयोग के लिए उपयुक्त है। यह ज्यादातर async/awaitसिंटैक्स के लिए है, लेकिन सामान्य प्रवाह के भीतर वास्तव में ऐसा कुछ भी नहीं है जिसमें इस तरह का कोई प्रतिबंध है, और सादे वादों के लिए थोड़े बदलाव के साथ या यहां तक कि सादे कॉलबैक कार्यान्वयन के लिए भी लागू होता है।
index.js
const { MongoClient } = require('mongodb');
const fs = require('mz/fs');
const uri = 'mongodb://localhost:27017';
const log = data => console.log(JSON.stringify(data, undefined, 2));
(async function() {
try {
const client = await MongoClient.connect(uri);
const db = client.db('bookDemo');
const books = db.collection('books');
let { version } = await db.command({ buildInfo: 1 });
version = parseFloat(version.match(new RegExp(/(?:(?!-).)*/))[0]);
// Clear and load books
await books.deleteMany({});
await books.insertMany(
(await fs.readFile('books.json'))
.toString()
.replace(/\n$/,"")
.split("\n")
.map(JSON.parse)
);
if ( version >= 3.6 ) {
// Non-correlated pipeline with limits
let result = await books.aggregate([
{ "$group": {
"_id": "$addr",
"count": { "$sum": 1 }
}},
{ "$sort": { "count": -1 } },
{ "$limit": 2 },
{ "$lookup": {
"from": "books",
"as": "books",
"let": { "addr": "$_id" },
"pipeline": [
{ "$match": {
"$expr": { "$eq": [ "$addr", "$$addr" ] }
}},
{ "$group": {
"_id": "$book",
"count": { "$sum": 1 },
}},
{ "$sort": { "count": -1 } },
{ "$limit": 2 }
]
}}
]).toArray();
log({ result });
}
// Serial result procesing with parallel fetch
// First get top addr items
let topaddr = await books.aggregate([
{ "$group": {
"_id": "$addr",
"count": { "$sum": 1 }
}},
{ "$sort": { "count": -1 } },
{ "$limit": 2 }
]).toArray();
// Run parallel top books for each addr
let topbooks = await Promise.all(
topaddr.map(({ _id: addr }) =>
books.aggregate([
{ "$match": { addr } },
{ "$group": {
"_id": "$book",
"count": { "$sum": 1 }
}},
{ "$sort": { "count": -1 } },
{ "$limit": 2 }
]).toArray()
)
);
// Merge output
topaddr = topaddr.map((d,i) => ({ ...d, books: topbooks[i] }));
log({ topaddr });
client.close();
} catch(e) {
console.error(e)
} finally {
process.exit()
}
})()
books.json
{ "addr": "address1", "book": "book1" }
{ "addr": "address2", "book": "book1" }
{ "addr": "address1", "book": "book5" }
{ "addr": "address3", "book": "book9" }
{ "addr": "address2", "book": "book5" }
{ "addr": "address2", "book": "book1" }
{ "addr": "address1", "book": "book1" }
{ "addr": "address15", "book": "book1" }
{ "addr": "address9", "book": "book99" }
{ "addr": "address90", "book": "book33" }
{ "addr": "address4", "book": "book3" }
{ "addr": "address5", "book": "book1" }
{ "addr": "address77", "book": "book11" }
{ "addr": "address1", "book": "book1" }