MongoDB - Agrégation Cadre (Nombre Total)

Il y a une solution à l'aide de push et de tranche: https://stackoverflow.com/a/39784851/4752635 (@emaniacs en parle très bien ici).

Mais je préfère utiliser 2 requêtes. Solution poussant $$ROOT et de l'utilisation de $tranche s'exécute dans le document limitation de la mémoire de 16 MO pour de grandes collections. Aussi, pour les grandes collections de deux requêtes semblent courir plus vite que celui de $$RACINE de pousser. Vous pouvez les exécuter en parallèle, de sorte que vous ne sont limitées que par le plus lent des deux requêtes (probablement celui qui trie).

1. Première de filtrage et de les grouper par ID pour obtenir le nombre d'éléments filtrés. Ne pas filtrer ici, c'est inutile.
2. Deuxième requête qui les filtres, les tris et les pagine.

J'ai réglé avec cette solution à l'aide de 2 requêtes de l'agrégation et de cadre (note - je utiliser node.js dans cet exemple):

var aggregation = [
{
//If you can match fields at the begining, match as many as early as possible.
$match: {...}
},
{
//Projection.
$project: {...}
},
{
//Some things you can match only after projection or grouping, so do it now.
$match: {...}
}
];
//Copy filtering elements from the pipeline - this is the same for both counting number of fileter elements and for pagination queries.
var aggregationPaginated = aggregation.slice(0);
//Count filtered elements.
aggregation.push(
{
$group: {
_id: null,
count: { $sum: 1 }
}
}
);
//Sort in pagination query.
aggregationPaginated.push(
{
$sort: sorting
}
);
//Paginate.
aggregationPaginated.push(
{
$limit: skip + length
},
{
$skip: skip
}
);
//I use mongoose.
//Get total count.
model.count(function(errCount, totalCount) {
//Count filtered.
model.aggregate(aggregation)
.allowDiskUse(true)
.exec(
function(errFind, documents) {
if (errFind) {
//Errors.
res.status(503);
return res.json({
'success': false,
'response': 'err_counting'
});
}
else {
//Number of filtered elements.
var numFiltered = documents[0].count;
//Filter, sort and pagiante.
model.request.aggregate(aggregationPaginated)
.allowDiskUse(true)
.exec(
function(errFindP, documentsP) {
if (errFindP) {
//Errors.
res.status(503);
return res.json({
'success': false,
'response': 'err_pagination'
});
}
else {
return res.json({
'success': true,
'recordsTotal': totalCount,
'recordsFiltered': numFiltered,
'response': documentsP
});
}
});
}
});
});

OriginalL'auteur Filip Voska

Si vous ne voulez pas exécuter deux requêtes en parallèle (un pour agréger les #postes pour vos meilleurs auteurs, et une autre agrégation pour calculer le total des postes pour tous les auteurs), vous pouvez simplement supprimer $limite sur le pipeline et sur les résultats, vous pouvez utiliser

totalCount = results.length;
results.slice(number of skip,number of skip + number of limit);

ex:

db.article.aggregate([
{ $group : {
_id : "$author",
posts : { $sum : 1 }
}},
{ $sort : { posts: -1 } }
//{$skip : yourSkip},    //--remove this
//{ $limit : yourLimit }, //remove this too
]).exec(function(err, results){
var totalCount = results.length;//--GEt total count here
results.slice(yourSkip,yourSkip+yourLimit);
});

OriginalL'auteur Công Thắng

J'ai eu le même problème, résolu avec $projet, $tranche et $$ROOT.

db.article.aggregate(
{ $group : {
_id : '$author',
posts : { $sum : 1 },
articles: {$push: '$$ROOT'},
}},
{ $sort : { posts: -1 } },
{ $project: {total: '$posts', articles: {$slice: ['$articles', from, to]}},
).toArray(function(err, result){
var articles = result[0].articles;
var total = result[0].total;
});

Vous devez déclarer from et to variable.

https://docs.mongodb.com/manual/reference/operator/aggregation/slice/

OriginalL'auteur emaniacs