MongoDB Aggregation: จะนับจำนวนระเบียนทั้งหมดได้อย่างไร?

ฉันใช้การรวมเพื่อดึงข้อมูลจาก 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),
));

หากฉันดำเนินการสืบค้นนี้โดยไม่ จำกัด จำนวนระเบียนจะถูกดึงข้อมูล 10 รายการ แต่ฉันต้องการ จำกัด เป็น 2 ดังนั้นฉันจึงต้องการนับจำนวนระเบียนทั้งหมด ฉันจะทำอย่างไรกับการรวม? กรุณาแนะนำฉัน. ขอบคุณ

นี่เป็นคำถามที่ถามบ่อยที่สุดเพื่อให้ได้ผลลัพธ์ที่มีการแบ่งหน้าและจำนวนผลลัพธ์ทั้งหมดพร้อมกันในแบบสอบถามเดียว ฉันไม่สามารถอธิบายได้ว่าฉันรู้สึกอย่างไรเมื่อในที่สุดฉันก็ทำได้ 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": [
      {...},
      {...},
      {...},
    ]
  }
]

เนื่องจาก 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 } } }
] );

คุณสามารถใช้ฟังก์ชัน toArray จากนั้นรับความยาวสำหรับจำนวนระเบียนทั้งหมด

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

ใช้ขั้นตอนไปป์ไลน์การรวมจำนวน $ countเพื่อรับจำนวนเอกสารทั้งหมด:

คำถาม:

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

ผลลัพธ์:

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

ฉันทำแบบนี้:

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

โซลูชันที่จัดทำโดย @Divergent ใช้งานได้ แต่จากประสบการณ์ของฉันมันจะดีกว่าที่จะมี 2 คำถาม:

1. อันดับแรกสำหรับการกรองแล้วจัดกลุ่มตาม ID เพื่อรับจำนวนองค์ประกอบที่กรอง อย่ากรองตรงนี้มันไม่จำเป็น
2. แบบสอบถามที่สองซึ่งกรองเรียงลำดับและเลขหน้า

การแก้ปัญหาด้วยการกด $$ ROOT และการใช้ $ slice จะทำงานในข้อ จำกัด หน่วยความจำเอกสารที่ 16MB สำหรับคอลเล็กชันขนาดใหญ่ นอกจากนี้สำหรับคอลเลกชันขนาดใหญ่สองการสืบค้นร่วมกันดูเหมือนว่าจะทำงานได้เร็วกว่าคำค้นหาที่มีการกด $$ 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
            });
          }
      });
    }
  });
});

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

ต่อไปนี้เป็นวิธีการรับจำนวนเร็กคอร์ดทั้งหมดในขณะที่ทำการ MongoDB Aggregation:

• ใช้$count:

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

  สำหรับการรับ 1,000 ระเบียนจะใช้เวลาโดยเฉลี่ย 2 ms และเป็นวิธีที่เร็วที่สุด

• ใช้.toArray():

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

  สำหรับการรับ 1,000 ระเบียนจะใช้เวลาโดยเฉลี่ย 18 ms

• ใช้.itcount():

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

  สำหรับการรับ 1,000 ระเบียนจะใช้เวลาโดยเฉลี่ย 14 ms

ซึ่งอาจใช้ได้กับเงื่อนไขการจับคู่หลายรายการ

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

ฉันต้องการจำนวนผลรวมสัมบูรณ์หลังจากใช้การรวม สิ่งนี้ใช้ได้ผลสำหรับฉัน:

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

ผลลัพธ์:

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

ขออภัยฉันคิดว่าคุณต้องมีคำถามสองข้อ หนึ่งสำหรับการดูทั้งหมดและอีกรายการหนึ่งสำหรับเรกคอร์ดที่จัดกลุ่ม

คำตอบนี้มีประโยชน์

หากคุณไม่ต้องการจัดกลุ่มให้ใช้วิธีการต่อไปนี้:

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