Agregação do MongoDB: como obter a contagem total de registros?

Eu usei agregação para buscar registros de mongodb.

$result = $collection->aggregate(array(
  array('$match' => $document),
  array('$group' => array('_id' => '$book_id', 'date' => array('$max' => '$book_viewed'),  'views' => array('$sum' => 1))),
  array('$sort' => $sort),
  array('$skip' => $skip),
  array('$limit' => $limit),
));

Se eu executar esta consulta sem limite, 10 registros serão obtidos. Mas quero manter o limite de 2. Portanto, gostaria de obter a contagem total de registros. Como posso fazer com agregação? Por favor, me aconselhe. obrigado

Esta é uma das perguntas mais frequentes para obter o resultado paginado e o número total de resultados simultaneamente em uma única consulta. Não posso explicar como me senti quando finalmente consegui LOL.

$result = $collection->aggregate(array(
  array('$match' => $document),
  array('$group' => array('_id' => '$book_id', 'date' => array('$max' => '$book_viewed'),  'views' => array('$sum' => 1))),
  array('$sort' => $sort),

// get total, AND preserve the results
  array('$group' => array('_id' => null, 'total' => array( '$sum' => 1 ), 'results' => array( '$push' => '$$ROOT' ) ),
// apply limit and offset
  array('$project' => array( 'total' => 1, 'results' => array( '$slice' => array( '$results', $skip, $length ) ) ) )
))

O resultado será mais ou menos assim:

[
  {
    "_id": null,
    "total": ...,
    "results": [
      {...},
      {...},
      {...},
    ]
  }
]

Desde a v.3.4 (eu acho) MongoDB tem agora um novo operador de pipeline de agregação chamado ' facet ' que em suas próprias palavras:

Processa vários pipelines de agregação em um único estágio no mesmo conjunto de documentos de entrada. Cada sub pipeline tem seu próprio campo no documento de saída, onde seus resultados são armazenados como uma matriz de documentos.

Neste caso específico, isso significa que se pode fazer algo assim:

$result = $collection->aggregate([
  { ...execute queries, group, sort... },
  { ...execute queries, group, sort... },
  { ...execute queries, group, sort... },
  $facet: {
    paginatedResults: [{ $skip: skipPage }, { $limit: perPage }],
    totalCount: [
      {
        $count: 'count'
      }
    ]
  }
]);

O resultado será (com por ex 100 resultados totais):

[
  {
    "paginatedResults":[{...},{...},{...}, ...],
    "totalCount":[{"count":100}]
  }
]

Use para encontrar a contagem total na coleção resultante.

db.collection.aggregate( [
{ $match : { score : { $gt : 70, $lte : 90 } } },
{ $group: { _id: null, count: { $sum: 1 } } }
] );

Você pode usar a função toArray e obter seu comprimento para a contagem total de registros.

db.CollectionName.aggregate([....]).toArray().length

Use o estágio de pipeline de agregação $ count para obter a contagem total de documentos:

Inquerir :

db.collection.aggregate(
  [
    {
      $match: {
        ...
      }
    },
    {
      $group: {
        ...
      }
    },
    {
      $count: "totalCount"
    }
  ]
)

Resultado:

{
   "totalCount" : Number of records (some integer value)
}

Eu fiz assim:

db.collection.aggregate([
     { $match : { score : { $gt : 70, $lte : 90 } } },
     { $group: { _id: null, count: { $sum: 1 } } }
] ).map(function(record, index){
        print(index);
 });

O agregado retornará a matriz, então apenas faça um loop e obtenha o índice final.

E outra maneira de fazer isso é:

var count = 0 ;
db.collection.aggregate([
{ $match : { score : { $gt : 70, $lte : 90 } } },
{ $group: { _id: null, count: { $sum: 1 } } }
] ).map(function(record, index){
        count++
 }); 
print(count);

A solução fornecida por @Divergent funciona, mas na minha experiência é melhor ter 2 consultas:

1. Primeiro para filtrar e depois agrupar por ID para obter o número de elementos filtrados. Não filtre aqui, é desnecessário.
2. Segunda consulta que filtra, classifica e pagina.

A solução com o envio de $$ ROOT e o uso de $ slice atinge a limitação de memória do documento de 16 MB para grandes coleções. Além disso, para grandes coleções, duas consultas juntas parecem executar mais rápido do que aquela com envio de $$ ROOT. Você também pode executá-los em paralelo, portanto, você está limitado apenas pela mais lenta das duas consultas (provavelmente aquela que classifica).

Resolvi esta solução usando 2 consultas e estrutura de agregação (nota - eu uso node.js neste exemplo, mas a ideia é a mesma):

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
            });
          }
      });
    }
  });
});

//const total_count = await User.find(query).countDocuments();
//const users = await User.find(query).skip(+offset).limit(+limit).sort({[sort]: order}).select('-password');
const result = await User.aggregate([
  {$match : query},
  {$sort: {[sort]:order}},
  {$project: {password: 0, avatarData: 0, tokens: 0}},
  {$facet:{
      users: [{ $skip: +offset }, { $limit: +limit}],
      totalCount: [
        {
          $count: 'count'
        }
      ]
    }}
  ]);
console.log(JSON.stringify(result));
console.log(result[0]);
return res.status(200).json({users: result[0].users, total_count: result[0].totalCount[0].count});

Isso pode funcionar para várias condições de correspondência

            const query = [
                {
                    $facet: {
                    cancelled: [
                        { $match: { orderStatus: 'Cancelled' } },
                        { $count: 'cancelled' }
                    ],
                    pending: [
                        { $match: { orderStatus: 'Pending' } },
                        { $count: 'pending' }
                    ],
                    total: [
                        { $match: { isActive: true } },
                        { $count: 'total' }
                    ]
                    }
                },
                {
                    $project: {
                    cancelled: { $arrayElemAt: ['$cancelled.cancelled', 0] },
                    pending: { $arrayElemAt: ['$pending.pending', 0] },
                    total: { $arrayElemAt: ['$total.total', 0] }
                    }
                }
                ]
                Order.aggregate(query, (error, findRes) => {})

Eu precisava da contagem total absoluta após aplicar a agregação. Isso funcionou para mim:

db.mycollection.aggregate([
    {
        $group: { 
            _id: { field1: "$field1", field2: "$field2" },
        }
    },
    { 
        $group: { 
            _id: null, count: { $sum: 1 } 
        } 
    }
])

Resultado:

{
    "_id" : null,
    "count" : 57.0
}

Aqui estão algumas maneiras de obter a contagem total de registros ao fazer a agregação do MongoDB:

• Usando $count:

  db.collection.aggregate([
     // Other stages here
     { $count: "Total" }
  ])

  Para obter 1000 registros, leva em média 2 ms e é o caminho mais rápido.

• Usando .toArray():

  db.collection.aggregate([...]).toArray().length

  Para obter 1000 registros, leva em média 18 ms.

• Usando .itcount():

  db.collection.aggregate([...]).itcount()

  Para obter 1000 registros, leva em média 14 ms.

Desculpe, mas acho que você precisa de duas perguntas. Um para visualizações totais e outro para registros agrupados.

Você pode achar útil esta resposta

Se você não quiser agrupar, use o seguinte método:

db.collection.aggregate( [ { $match : { score : { $gt : 70, $lte : 90 } } }, { $count: 'count' } ] );