MongoDB Aggregation: Toplam kayıt sayısı nasıl alınır?

Mongodb'den kayıtları almak için toplama kullandım.

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

Bu sorguyu sınırsız olarak yürütürsem, 10 kayıt getirilecek. Ama limiti 2 olarak tutmak istiyorum. Bu yüzden toplam kayıt sayısını almak istiyorum. Toplama ile nasıl yapabilirim? Lütfen bana tavsiye verin. Teşekkürler

Bu, sayfalara ayrılmış sonucu ve tek bir sorguda aynı anda toplam sonuç sayısını elde etmek için en sık sorulan sorulardan biridir. Nihayet LOL'a ulaştığımda nasıl hissettiğimi açıklayamam.

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

Sonuç şunun gibi görünecek:

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

V.3.4'ten bu yana (sanırım) MongoDB artık kendi sözleriyle ' facet ' adında yeni bir toplama işlem hattı operatörüne sahip:

Aynı girdi belgeleri kümesindeki tek bir aşamada birden çok toplama işlem hattını işler. Her bir alt boru hattının, sonuçlarının bir belge dizisi olarak saklandığı çıktı belgesinde kendi alanı vardır.

Bu özel durumda, bu, şu gibi bir şey yapılabileceği anlamına gelir:

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

Sonuç şu şekilde olacaktır (ör. 100 toplam sonuç için):

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

Elde edilen koleksiyondaki toplam sayıyı bulmak için bunu kullanın.

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

ToArray işlevini kullanabilir ve ardından toplam kayıt sayısı için uzunluğunu öğrenebilirsiniz.

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

Toplam belge sayısını elde etmek için $ count toplama işlem hattı aşamasını kullanın:

Sorgu :

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

Sonuç:

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

Ben şu şekilde yaptım:

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

Toplam, diziyi döndürecektir, bu yüzden onu döngüye sok ve son dizini al.

Ve bunu yapmanın başka bir yolu:

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

@Divergent tarafından sağlanan çözüm işe yarıyor, ancak deneyimlerime göre 2 sorgu olması daha iyi:

1. Önce filtreleme ve ardından filtrelenen öğelerin sayısını almak için kimliğe göre gruplama için. Burada filtreleme yapmayın, gereksizdir.
2. Filtreleyen, sıralayan ve sayfalandıran ikinci sorgu.

$$ ROOT'u zorlayarak ve $ dilim kullanarak çözüm, büyük koleksiyonlar için 16MB'lık belge bellek sınırlamasına girer. Ayrıca, büyük koleksiyonlar için, iki sorgu birlikte $$ ROOT zorlamasına göre daha hızlı çalışıyor gibi görünüyor. Bunları paralel olarak da çalıştırabilirsiniz, böylece yalnızca iki sorgudan daha yavaş olanı (muhtemelen sıralayan) sınırlandırırsınız.

Bu çözüme 2 sorgu ve toplama çerçevesi kullanarak karar verdim (not - bu örnekte node.js kullanıyorum, ancak fikir aynı):

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

Bu, çoklu maç koşulları için işe yarayabilir

            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) => {})

MongoDB Aggregation yaparken toplam kayıt sayısını almanın bazı yolları:

• Kullanarak $count:

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

  1000 kayıt almak için bu ortalama 2 ms sürer ve en hızlı yoldur.

• Kullanarak .toArray():

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

  1000 kayıt almak için bu ortalama 18 ms sürer.

• Kullanarak .itcount():

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

  1000 kayıt almak için bu ortalama 14 ms sürer.

Toplamayı uyguladıktan sonra mutlak toplam sayısına ihtiyacım vardı. Bu benim için çalıştı:

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

Sonuç:

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

Üzgünüm ama sanırım iki sorguya ihtiyacın var. Biri toplam görünümler ve diğeri gruplanmış kayıtlar için.

Bu cevabı faydalı bulabilirsin

Gruplamak istemiyorsanız, aşağıdaki yöntemi kullanın:

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