Как использовать функцию count () для агрегатной функции в PyMongo [duplicate]

Вы можете использовать функцию toArray, а затем получить ее длину для общего количества записей.

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

Это один из наиболее часто задаваемых вопросов для получения разбитого на результат результата и общего количества результатов одновременно в одном запросе. Я не могу объяснить, как я себя чувствовал, когда я, наконец, достиг этого 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 ) ) ) )
))

Результат будет выглядеть примерно так:

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

Использовать счетчик $ count, чтобы получить итоговый результат агрегирования

Запрос:

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

Результат:

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

Извините, но я думаю, вам нужны два запроса.

Вы можете найти полезный этот ответ

Решение, предоставляемое @Divergent, работает, но по моему опыту лучше иметь 2 запроса:

1. Сначала для фильтрации и затем группировки по идентификатору для получения количества фильтрованных элементов.
2. Второй запрос, который фильтрует, сортирует и разбивает страницы.

Решение с нажатием $$ ROOT и использованием $ slice запускается в память документа ограничение 16 МБ для больших коллекций. Кроме того, для больших коллекций два запроса вместе работают быстрее, чем один с нажатием $$ ROOT. Вы также можете запускать их параллельно, поэтому вы ограничены только медленными из двух запросов (вероятно, тот, который сортирует).

Я решил использовать это решение, используя 2 запроса и структуру агрегации (примечание - Я использую node.js в этом примере, но идея такая же):

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

Я сделал это следующим образом:

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

Агрегат вернет массив, поэтому просто зациклируйте его и получите окончательный индекс.

И другим способом сделать это:

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

Поскольку v.3.4 (я думаю), у MongoDB теперь появился новый оператор конвейера агрегации с именем « facet », который своими словами:

обрабатывает несколько агрегатных конвейеров в течение одного этапа на одном и том же наборе входных документов. Каждый субподвод имеет свое собственное поле в выходном документе, где его результаты хранятся в виде массива документов.

В этом конкретном случае это означает, что можно сделать что-то вроде этого:

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

Результат будет (при этом для 100 итоговых результатов):

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

Используйте это, чтобы найти общий счет в коллекции.

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