TLDR-Zusammenfassung
In modernen MongoDB-Releases können Sie dies mit $slicenur dem grundlegenden Aggregationsergebnis brutal erzwingen . Für „große“ Ergebnisse, führen parallele Abfragen statt für jede Gruppierung (eine Demonstration Auflistung ist am Ende der Antwort) oder warten , SERVER-9377 zu lösen, die eine „Grenze“ , um die Anzahl der Elemente ermöglichen würde $pushzu einem Array.
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 Vorschau
SERVER-9377 wird immer noch nicht aufgelöst , aber in dieser Version $lookupwird eine neue "nicht korrelierte" Option zugelassen, die "pipeline"anstelle der Optionen "localFields"und einen Ausdruck als Argument verwendet "foreignFields". Dies ermöglicht dann einen "Self-Join" mit einem anderen Pipeline-Ausdruck, in dem wir anwenden $limitkönnen, um die "Top-n" -Ergebnisse zurückzugeben.
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"
}}
])
Die andere dazu hier ist natürlich die Fähigkeit , die Variable durch die Interpolation $exprunter Verwendung $matchauszuwählen , um die passenden Artikel in dem „join“, aber die allgemeine Prämisse ist eine „Pipeline innerhalb einer Pipeline“ , wo der innere Gehalt von Übereinstimmungen aus dem Mutter gefiltert werden kann . Da beide selbst "Pipelines" sind, können wir $limitjedes einzeln ergeben.
Dies wäre die nächstbeste Option zum Ausführen paralleler Abfragen und wäre tatsächlich besser, wenn sie $matcheinen Index in der "Sub-Pipeline" -Verarbeitung verwenden könnten und könnten. Was also nicht das "Limit auf $push" verwendet, wie es in dem genannten Problem verlangt wird, liefert tatsächlich etwas, das besser funktionieren sollte.
Ursprünglicher Inhalt
Sie scheinen auf das oberste "N" -Problem gestoßen zu sein. In gewisser Weise ist Ihr Problem ziemlich einfach zu lösen, jedoch nicht mit der genauen Einschränkung, nach der Sie fragen:
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 }
])
Das ergibt ein Ergebnis wie das folgende:
{
"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
}
Dies unterscheidet sich also von dem, was Sie verlangen, da wir zwar die besten Ergebnisse für die Adresswerte erhalten, die zugrunde liegende Auswahl der "Bücher" jedoch nicht nur auf eine erforderliche Anzahl von Ergebnissen beschränkt ist.
Dies stellt sich als sehr schwierig heraus, kann jedoch durchgeführt werden, obwohl die Komplexität nur mit der Anzahl der Elemente zunimmt, die Sie anpassen müssen. Um es einfach zu halten, können wir dies bei höchstens 2 Spielen belassen:
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 } }
])
Das gibt Ihnen also tatsächlich die Top 2 "Bücher" aus den Top 2 "Adress" -Einträgen.
Aber für mein Geld bleib bei der ersten Form und "schneide" dann einfach die Elemente des Arrays, die zurückgegeben werden, um die ersten "N" Elemente zu nehmen.
Demonstrationscode
Der Demonstrationscode ist für die Verwendung mit aktuellen LTS-Versionen von NodeJS aus den Versionen v8.x und v10.x geeignet. Das ist hauptsächlich für die async/awaitSyntax gedacht, aber es gibt nichts wirklich im allgemeinen Ablauf, das eine solche Einschränkung aufweist und sich mit geringen Änderungen an einfache Versprechen oder sogar an die einfache Rückrufimplementierung anpasst.
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" }
Die folgende Abfrage liefert genau das gleiche Ergebnis wie in der gewünschten Antwort:
Die Antwort sieht wie folgt aus:
quelle