Breaking News: Grepper is joining You.com. Read the official announcement!

pagination with aggregate in MongoDb

Add Answer

Jaimin Patel answered on April 29, 2020 Popularity 8/10 Helpfulness 3/10

answer pagination with aggregate in MongoDb

related pagination in mongodb query

related mongo db pagination with aggregate

related pagination mongodb

related mongodb aggregation pagination

pagination with aggregate in MongoDb

Comment

db.Order.aggregate([
    { '$match'    : { "company_id" : ObjectId("54c0...") } },
    { '$sort'     : { 'order_number' : -1 } },
    { '$facet'    : {
        metadata: [ { $count: "total" }, { $addFields: { page: NumberInt(3) } } ],
        data: [ { $skip: 20 }, { $limit: 10 } ] // add projection here wish you re-shape the docs
    } }
] )

Popularity 8/10 Helpfulness 3/10 Language whatever

Source: stackoverflow.com

Tags: aggregate mongodb pagination whatever

Link to this answer
Share Copy Link

Contributed on Feb 16 2023

Jaimin Patel

0 Answers Avg Quality 2/10

Closely Related Answers

pagination in mongodb query

Comment

const noOfRecordsPerPage = 10; // number of records par page
const userData = await database
    .collection("users")
    .find() // search on all data
    .sort({ _id: -1 }) // reverse the data to get latest record first
    .skip(parseInt(page) * noOfRecordsPerPage) // skip the records base on page number
    .limit(noOfRecordsPerPage) // no of record par page
    .toArray(); // turn the records into array

Popularity 9/10 Helpfulness 4/10 Language javascript

Source: Grepper

Tags: javascript j

Link to this answer
Share Copy Link

Contributed on Sep 12 2023

Sujal Dankhara

0 Answers Avg Quality 2/10

mongo db pagination with aggregate

Comment

db.Order.aggregate([
    {$match: {company_id: ObjectId("54c0...") } },
    {$sort: {order_number: -1 } },
    {$setWindowFields: {output: {totalCount: {$count: {}}}}}
    {$skip: 20 },
    {$limit: 10 } 
])

Popularity 10/10 Helpfulness 4/10 Language whatever

Source: stackoverflow.com

Tags: aggregate aggr

Link to this answer
Share Copy Link

Contributed on Oct 23 2022

Rashid P

0 Answers Avg Quality 2/10

pagination mongodb

Comment

    def skiplimit(page_size, page_num):
        """returns a set of documents belonging to page number `page_num`
        where size of each page is `page_size`.
        """
        # Calculate number of documents to skip
        skips = page_size * (page_num - 1)

        # Skip and limit
        cursor = db['students'].find().skip(skips).limit(page_size)

        # Return documents
        return [x for x in cursor]

Popularity 10/10 Helpfulness 3/10 Language whatever

Source: www.codementor.io

Tags: mongodb

Link to this answer
Share Copy Link

Contributed on Apr 29 2020

Odd Octopus

0 Answers Avg Quality 2/10

mongodb aggregation pagination

Comment

db.Order.aggregate([
    { '$match'    : { "company_id" : ObjectId("54c0...") } },
    { '$sort'     : { 'order_number' : -1 } },
    { '$facet'    : {
        metadata: [ { $count: "total" }, { $addFields: { page: NumberInt(3) } } ],
        data: [ { $skip: 20 }, { $limit: 10 } ] // add projection here wish you re-shape the docs
    } }
] )

Popularity 5/10 Helpfulness 2/10 Language whatever

Source: stackoverflow.com

Tags: mongodb-aggregation pagination whatever what

Link to this answer
Share Copy Link

Contributed on Jul 10 2023

DreamCoder

0 Answers Avg Quality 2/10

mongodb aggregation pagination

Comment

 let {
    allPostsPage = 1,
    followingPostsPage = 1,
    limit = 25,
    userId,
    fetchOthersPosts,
  } = req.query;
  const blockedUsers = await BlockUsers.aggregate([
    {
      $match: {
        $or: [
          { userId: mongoose.Types.ObjectId(userId) },
          { blockedUserId: mongoose.Types.ObjectId(userId) },
        ],
      },
    },
  ]);
  allPostsPage = parseInt(allPostsPage);
  followingPostsPage = parseInt(followingPostsPage);

  const blockedUserIds = [];
  blockedUsers.map((user) => {
    if (user.userId.toString() === userId.toString()) {
      blockedUserIds.push(user.blockedUserId);
    } else if (user.blockedUserId.toString() === userId.toString()) {
      blockedUserIds.push(user.userId);
    }
  });

  let noMoreFollowingPosts = false;
  let posts = [];
  let fakeTotalPagesFlag = false;

  let initialPosts = [];

  const followingList = await Followers.aggregate([
    { $match: { following: mongoose.Types.ObjectId(userId) } },
    { $project: { userId: 1, _id: 0, requestAccepted: 1 } },
  ]);

  const followingListIds = []
  followingList.map((e) => {
    if (e.requestAccepted === true || !e.hasOwnProperty("requestAccepted")) {
      followingListIds.push(mongoose.Types.ObjectId(e.userId));
    }
  });

  let noFollowers = false;
  if (followingListIds.length < 1) {
    fetchOthersPosts = "true";
    noFollowers = true;
  }

  // let queryFilter=;

  if (fetchOthersPosts === "false") {

    posts = await Post.aggregate([
      {
        $lookup: {
          from: "users",
          let: { userId: "$userId" },
          pipeline: [
            {
              $match: {
                $expr: { $eq: ["$_id", "$$userId"] },
              },
            },
            { $project: { fullName: 1, userName: 1, email: 1, image: 1, privateAccount: 1 } },
          ],
          as: "users",
        },
      },
      {
        $addFields: {
          userId: {
            $arrayElemAt: ["$users", 0],
          },
          dayssince: {
            $trunc: {
              $divide: [
                { $subtract: [new Date(), "$createdAt"] },
                1000 * 60 * 60 * 24,
              ],
            },
          },
        },
      },
      {
        $match: {
          $or: [
            { "userId._id": { $in: followingListIds } },
            {
              $and: [
                { "userId._id": mongoose.Types.ObjectId(userId) },
                { dayssince: { $lt: 2 } },
              ],
            },
          ],
        },
      },
      {
        $lookup: {
          from: "ingredients",
          localField: "ingredients.id",
          foreignField: "_id",
          as: "output"
        }
      },
      {
        $addFields: {
          "ingredients.name": "$output.name"
        }
      },
      { $project: { output: 0, postLikes: 0, userLiked: 0, ingredient: 0, dayssince: 0, users: 0, comments: 0, image: 0, video: 0 } },
      { $sort: { createdAt: -1 } },
      {
        $facet: {
          stage1: [{ $group: { _id: null, count: { $sum: 1 } } }],
          stage2: [
            {
              $skip: (followingPostsPage - 1) * limit,
            },
            { $limit: limit * 1 },
          ],
        },
      },
      {
        $unwind: {
          path: "$stage1",
        },
      },
      {
        $project: {
          count: "$stage1.count",
          data: "$stage2",
        },
      },
    ]);

    let filteredPostsCount = posts[0] ? posts[0].data.length : 0;

    let count = posts[0] ? posts[0].count : 0;

Popularity 9/10 Helpfulness 2/10 Language go

Source: Grepper

Tags: go mongodb-aggregation mong

Link to this answer
Share Copy Link

Contributed on Mar 08 2022

Bloody Bear

0 Answers Avg Quality 2/10

pagination with aggregate in MongoDb

Contents

More Related Answers

pagination with aggregate in MongoDb

Closely Related Answers

pagination in mongodb query

mongo db pagination with aggregate

pagination mongodb

mongodb aggregation pagination

mongodb aggregation pagination

Grepper

Documentation

Social

Legal

Contact

Oops, You will need to install Grepper and log-in to perform this action.