Wie paginiere ich mit Mongoose in Node.js?

Ich schreibe eine Webapp mit Node.js und Mungo. Wie kann ich die Ergebnisse eines .find()Anrufs paginieren ? Ich möchte eine Funktionalität, die mit "LIMIT 50,100"SQL vergleichbar ist .

Ich bin sehr enttäuscht von den akzeptierten Antworten in dieser Frage. Dies wird nicht skaliert. Wenn Sie das Kleingedruckte auf cursor.skip () lesen:

Die Methode cursor.skip () ist häufig teuer, da der Server vom Anfang der Sammlung oder des Index gehen muss, um die Offset- oder Sprungposition abzurufen, bevor das Ergebnis zurückgegeben wird. Mit zunehmendem Offset (z. B. Seitennummer oben) wird cursor.skip () langsamer und CPU-intensiver. Bei größeren Sammlungen kann cursor.skip () an die E / A gebunden werden.

Um eine skalierbare Paginierung zu erreichen, kombinieren Sie ein Limit () mit mindestens einem Filterkriterium. Ein Erstellungsdatum eignet sich für viele Zwecke.

MyModel.find( { createdOn: { $lte: request.createdOnBefore } } )
.limit( 10 )
.sort( '-createdOn' )

Nachdem ich mir die Mongoose-API mit den von Rodolphe bereitgestellten Informationen genauer angesehen hatte, fand ich diese Lösung heraus:

MyModel.find(query, fields, { skip: 10, limit: 5 }, function(err, results) { ... });

Paginierung mit Mungo, Express und Jade - Hier ist ein Link zu meinem Blog mit mehr Details

var perPage = 10
  , page = Math.max(0, req.param('page'))

Event.find()
    .select('name')
    .limit(perPage)
    .skip(perPage * page)
    .sort({
        name: 'asc'
    })
    .exec(function(err, events) {
        Event.count().exec(function(err, count) {
            res.render('events', {
                events: events,
                page: page,
                pages: count / perPage
            })
        })
    })

Sie können einfach so verketten:

var query = Model.find().sort('mykey', 1).skip(2).limit(5)

Führen Sie die Abfrage mit aus exec

query.exec(callback);

In diesem Fall können Sie die Abfrage pageund / oder limitIhre URL als Abfragezeichenfolge hinzufügen .

Beispielsweise:
?page=0&limit=25 // this would be added onto your URL: http:localhost:5000?page=0&limit=25

Da es ein wäre, müssen Stringwir es Numberfür unsere Berechnungen in ein konvertieren . Machen wir es mit der parseIntMethode und geben wir auch einige Standardwerte an.

const pageOptions = {
    page: parseInt(req.query.page, 10) || 0,
    limit: parseInt(req.query.limit, 10) || 10
}

sexyModel.find()
    .skip(pageOptions.page * pageOptions.limit)
    .limit(pageOptions.limit)
    .exec(function (err, doc) {
        if(err) { res.status(500).json(err); return; };
        res.status(200).json(doc);
    });

BTW Paginierung beginnt mit0

Sie können ein kleines Paket namens Mongoose Paginate verwenden , das es einfacher macht.

$ npm install mongoose-paginate

Fügen Sie nach Ihren Routen oder Ihrem Controller einfach Folgendes hinzu:

/**
 * querying for `all` {} items in `MyModel`
 * paginating by second page, 10 items per page (10 results, page 2)
 **/

MyModel.paginate({}, 2, 10, function(error, pageCount, paginatedResults) {
  if (error) {
    console.error(error);
  } else {
    console.log('Pages:', pageCount);
    console.log(paginatedResults);
  }
}

Dies ist ein Beispielbeispiel, das Sie ausprobieren können.

var _pageNumber = 2,
  _pageSize = 50;

Student.count({},function(err,count){
  Student.find({}, null, {
    sort: {
      Name: 1
    }
  }).skip(_pageNumber > 0 ? ((_pageNumber - 1) * _pageSize) : 0).limit(_pageSize).exec(function(err, docs) {
    if (err)
      res.json(err);
    else
      res.json({
        "TotalCount": count,
        "_Array": docs
      });
  });
 });

Versuchen Sie, die Mungofunktion für die Paginierung zu verwenden. Limit ist die Anzahl der Datensätze pro Seite und die Anzahl der Seiten.

var limit = parseInt(body.limit);
var skip = (parseInt(body.page)-1) * parseInt(limit);

 db.Rankings.find({})
            .sort('-id')
            .limit(limit)
            .skip(skip)
            .exec(function(err,wins){
 });

Das habe ich mit Code gemacht

var paginate = 20;
var page = pageNumber;
MySchema.find({}).sort('mykey', 1).skip((pageNumber-1)*paginate).limit(paginate)
    .exec(function(err, result) {
        // Write some stuff here
    });

So habe ich es gemacht.

Abfrage;
search = productName,

Params;
Seite = 1

// Pagination
router.get("/search/:page", (req, res, next) => {
  const resultsPerPage = 5;
  const page = req.params.page >= 1 ? req.params.page : 1;
  const query = req.query.search;

  Product.find({ name: query })
    .select("name")
    .sort({ name: "asc" })
    .limit(resultsPerPage)
    .skip(resultsPerPage * page)
    .then((results) => {
      return res.status(200).send(results);
    })
    .catch((err) => {
      return res.status(500).send(err);
    });
});

Hier ist eine Version, die ich an alle meine Modelle anhänge. Dies hängt vom Unterstrich ab und ist für die Leistung asynchron. Die Optionen ermöglichen die Auswahl und Sortierung von Feldern mithilfe der Mungosyntax.

var _ = require('underscore');
var async = require('async');

function findPaginated(filter, opts, cb) {
  var defaults = {skip : 0, limit : 10};
  opts = _.extend({}, defaults, opts);

  filter = _.extend({}, filter);

  var cntQry = this.find(filter);
  var qry = this.find(filter);

  if (opts.sort) {
    qry = qry.sort(opts.sort);
  }
  if (opts.fields) {
    qry = qry.select(opts.fields);
  }

  qry = qry.limit(opts.limit).skip(opts.skip);

  async.parallel(
    [
      function (cb) {
        cntQry.count(cb);
      },
      function (cb) {
        qry.exec(cb);
      }
    ],
    function (err, results) {
      if (err) return cb(err);
      var count = 0, ret = [];

      _.each(results, function (r) {
        if (typeof(r) == 'number') {
          count = r;
        } else if (typeof(r) != 'number') {
          ret = r;
        }
      });

      cb(null, {totalCount : count, results : ret});
    }
  );

  return qry;
}

Hängen Sie es an Ihr Modellschema an.

MySchema.statics.findPaginated = findPaginated;

Die obige Antwort gilt.

Nur ein Add-On für alle, die eher auf Async-Warten als auf Versprechen stehen !!

const findAllFoo = async (req, resp, next) => {
    const pageSize = 10;
    const currentPage = 1;

    try {
        const foos = await FooModel.find() // find all documents
            .skip(pageSize * (currentPage - 1)) // we will not retrieve all records, but will skip first 'n' records
            .limit(pageSize); // will limit/restrict the number of records to display

        const numberOfFoos = await FooModel.countDocuments(); // count the number of records for that model

        resp.setHeader('max-records', numberOfFoos);
        resp.status(200).json(foos);

    } catch (err) {
        resp.status(500).json({
            message: err
        });
    }
};

Einfache und leistungsstarke Paginierungslösung

async getNextDocs(no_of_docs_required: number, last_doc_id?: string) {
    let docs

    if (!last_doc_id) {
        // get first 5 docs
        docs = await MySchema.find().sort({ _id: -1 }).limit(no_of_docs_required)
    }
    else {
        // get next 5 docs according to that last document id
        docs = await MySchema.find({_id: {$lt: last_doc_id}})
                                    .sort({ _id: -1 }).limit(no_of_docs_required)
    }
    return docs
}

last_doc_id: Die letzte Dokument-ID, die Sie erhalten

no_of_docs_required: Die Anzahl der Dokumente, die Sie abrufen möchten, z. B. 5, 10, 50 usw.

1. Wenn Sie last_doc_iddie Methode nicht angeben , erhalten Sie dh 5 neueste Dokumente
2. Wenn Sie das bereitgestellt haben, erhalten last_doc_idSie die nächsten, dh 5 Dokumente.

Sie können auch die folgende Codezeile verwenden

per_page = parseInt(req.query.per_page) || 10
page_no = parseInt(req.query.page_no) || 1
var pagination = {
  limit: per_page ,
  skip:per_page * (page_no - 1)
}
users = await User.find({<CONDITION>}).limit(pagination.limit).skip(pagination.skip).exec()

Dieser Code funktioniert in der neuesten Version von Mongo

Ein solider Ansatz, um dies zu implementieren, besteht darin, die Werte vom Frontend mithilfe einer Abfragezeichenfolge zu übergeben . Lassen Sie uns sagen , dass wir erhalten möchten Seite # 2 und auch begrenzen die Ausgabe auf 25 Ergebnisse .
Die Abfragezeichenfolge würde folgendermaßen aussehen:?page=2&limit=25 // this would be added onto your URL: http:localhost:5000?page=2&limit=25

Sehen wir uns den Code an:

// We would receive the values with req.query.<<valueName>>  => e.g. req.query.page
// Since it would be a String we need to convert it to a Number in order to do our
// necessary calculations. Let's do it using the parseInt() method and let's also provide some default values:

  const page = parseInt(req.query.page, 10) || 1; // getting the 'page' value
  const limit = parseInt(req.query.limit, 10) || 25; // getting the 'limit' value
  const startIndex = (page - 1) * limit; // this is how we would calculate the start index aka the SKIP value
  const endIndex = page * limit; // this is how we would calculate the end index

// We also need the 'total' and we can get it easily using the Mongoose built-in **countDocuments** method
  const total = await <<modelName>>.countDocuments();

// skip() will return a certain number of results after a certain number of documents.
// limit() is used to specify the maximum number of results to be returned.

// Let's assume that both are set (if that's not the case, the default value will be used for)

  query = query.skip(startIndex).limit(limit);

  // Executing the query
  const results = await query;

  // Pagination result 
 // Let's now prepare an object for the frontend
  const pagination = {};

// If the endIndex is smaller than the total number of documents, we have a next page
  if (endIndex < total) {
    pagination.next = {
      page: page + 1,
      limit
    };
  }

// If the startIndex is greater than 0, we have a previous page
  if (startIndex > 0) {
    pagination.prev = {
      page: page - 1,
      limit
    };
  }

 // Implementing some final touches and making a successful response (Express.js)

const advancedResults = {
    success: true,
    count: results.length,
    pagination,
    data: results
 }
// That's it. All we have to do now is send the `results` to the frontend.
 res.status(200).json(advancedResults);

Ich würde vorschlagen, diese Logik in Middleware zu implementieren, damit Sie sie für verschiedene Routen / Controller verwenden können.

Der einfachste und schnellere Weg ist, mit dem objectId-Beispiel zu paginieren.

Anfangslastzustand

condition = {limit:12, type:""};

Nehmen Sie die erste und letzte ObjectId aus den Antwortdaten

Seite nächste Bedingung

condition = {limit:12, type:"next", firstId:"57762a4c875adce3c38c662d", lastId:"57762a4c875adce3c38c6615"};

Seite nächste Bedingung

condition = {limit:12, type:"next", firstId:"57762a4c875adce3c38c6645", lastId:"57762a4c875adce3c38c6675"};

Im Mungo

var condition = {};
    var sort = { _id: 1 };
    if (req.body.type == "next") {
        condition._id = { $gt: req.body.lastId };
    } else if (req.body.type == "prev") {
        sort = { _id: -1 };
        condition._id = { $lt: req.body.firstId };
    }

var query = Model.find(condition, {}, { sort: sort }).limit(req.body.limit);

query.exec(function(err, properties) {
        return res.json({ "result": result);
});

Der beste Ansatz (IMO) ist das Überspringen und Begrenzen von ABER innerhalb begrenzter Sammlungen oder Dokumente.

Um die Abfrage in begrenzten Dokumenten durchzuführen, können wir einen bestimmten Index wie einen Index für ein Feld vom Typ DATE verwenden. Siehe das unten

let page = ctx.request.body.page || 1
let size = ctx.request.body.size || 10
let DATE_FROM = ctx.request.body.date_from
let DATE_TO = ctx.request.body.date_to

var start = (parseInt(page) - 1) * parseInt(size)

let result = await Model.find({ created_at: { $lte: DATE_FROM, $gte: DATE_TO } })
    .sort({ _id: -1 })
    .select('<fields>')
    .skip( start )
    .limit( size )        
    .exec(callback)

Einfachstes Plugin für die Paginierung.

https://www.npmjs.com/package/mongoose-paginate-v2

Fügen Sie einem Schema ein Plugin hinzu und verwenden Sie dann die Modell-Paginate-Methode:

var mongoose         = require('mongoose');
var mongoosePaginate = require('mongoose-paginate-v2');

var mySchema = new mongoose.Schema({ 
    /* your schema definition */ 
});

mySchema.plugin(mongoosePaginate);

var myModel = mongoose.model('SampleModel',  mySchema); 

myModel.paginate().then({}) // Usage

Dies ist eine Beispielfunktion, um das Ergebnis eines Skills-Modells mit Paginierungs- und Limit-Optionen zu erhalten

 export function get_skills(req, res){
     console.log('get_skills');
     var page = req.body.page; // 1 or 2
     var size = req.body.size; // 5 or 10 per page
     var query = {};
     if(page < 0 || page === 0)
     {
        result = {'status': 401,'message':'invalid page number,should start with 1'};
        return res.json(result);
     }
     query.skip = size * (page - 1)
     query.limit = size
     Skills.count({},function(err1,tot_count){ //to get the total count of skills
      if(err1)
      {
         res.json({
            status: 401,
            message:'something went wrong!',
            err: err,
         })
      }
      else 
      {
         Skills.find({},{},query).sort({'name':1}).exec(function(err,skill_doc){
             if(!err)
             {
                 res.json({
                     status: 200,
                     message:'Skills list',
                     data: data,
                     tot_count: tot_count,
                 })
             }
             else
             {
                 res.json({
                      status: 401,
                      message: 'something went wrong',
                      err: err
                 })
             }
        }) //Skills.find end
    }
 });//Skills.count end

}}

Sie können eine solche Abfrage schreiben.

mySchema.find().skip((page-1)*per_page).limit(per_page).exec(function(err, articles) {
        if (err) {
            return res.status(400).send({
                message: err
            });
        } else {
            res.json(articles);
        }
    });

Seite: Seitennummer vom Client als Anforderungsparameter.
per_page: Anzahl der pro Seite angezeigten Ergebnisse

Wenn Sie den MEAN-Stack verwenden, enthält der folgende Blog-Beitrag viele Informationen zum Erstellen einer Paginierung im Front-End mithilfe des Bootstraps mit eckiger Benutzeroberfläche und der Verwendung von Mungo-Skip- und Limit-Methoden im Backend.

siehe: https://techpituwa.wordpress.com/2015/06/06/mean-js-pagination-with-angular-ui-bootstrap/

Sie können entweder skip () und limit () verwenden, aber es ist sehr ineffizient. Eine bessere Lösung wäre eine Sortierung nach indiziertem Feld plus limit (). Wir bei Wunderflats haben hier eine kleine Bibliothek veröffentlicht: https://github.com/wunderflats/goosepage Es verwendet den ersten Weg.

Wenn Sie Mungo als Quelle für eine erholsame API verwenden, schauen Sie sich ' restify-mongoose ' an ' und seine Abfragen an. Es hat genau diese Funktionalität eingebaut.

Jede Abfrage in einer Sammlung enthält Header, die hier hilfreich sind

test-01:~$ curl -s -D - localhost:3330/data?sort=-created -o /dev/null
HTTP/1.1 200 OK
link: </data?sort=-created&p=0>; rel="first", </data?sort=-created&p=1>; rel="next", </data?sort=-created&p=134715>; rel="last"
.....
Response-Time: 37

Grundsätzlich erhalten Sie also einen generischen Server mit einer relativ linearen Ladezeit für Abfragen an Sammlungen. Das ist großartig und etwas zu sehen, wenn Sie in eine eigene Implementierung gehen möchten.

app.get("/:page",(req,res)=>{
        post.find({}).then((data)=>{
            let per_page = 5;
            let num_page = Number(req.params.page);
            let max_pages = Math.ceil(data.length/per_page);
            if(num_page == 0 || num_page > max_pages){
                res.render('404');
            }else{
                let starting = per_page*(num_page-1)
                let ending = per_page+starting
                res.render('posts', {posts:data.slice(starting,ending), pages: max_pages, current_page: num_page});
            }
        });
});

**//localhost:3000/asanas/?pageNo=1&size=3**

//requiring asanas model
const asanas = require("../models/asanas");


const fetchAllAsanasDao = () => {
    return new Promise((resolve, reject) => {

    var pageNo = parseInt(req.query.pageNo);
    var size = parseInt(req.query.size);
    var query = {};
        if (pageNo < 0 || pageNo === 0) {
            response = {
                "error": true,
                "message": "invalid page number, should start with 1"
            };
            return res.json(response);
        }
        query.skip = size * (pageNo - 1);
        query.limit = size;

  asanas
            .find(pageNo , size , query)
        .then((asanasResult) => {
                resolve(asanasResult);
            })
            .catch((error) => {
                reject(error);
            });

    });
}

Verwenden Sie dieses einfache Plugin.

https://github.com/WebGangster/mongoose-paginate-v2

Installation

npm install mongoose-paginate-v2

const mongoose         = require('mongoose');
const mongoosePaginate = require('mongoose-paginate-v2');

const mySchema = new mongoose.Schema({ 
  /* your schema definition */ 
});

mySchema.plugin(mongoosePaginate);

const myModel = mongoose.model('SampleModel',  mySchema); 

myModel.paginate().then({}) // Usage

gemäß

Chris Hinkle

Antworten:

//assume every page has 50 result
const results = (req.query.page * 1) * 50;
MyModel.find( { fieldNumber: { $lte: results} })
.limit( 50 )
.sort( '+fieldNumber' )

//one thing left is create a fieldNumber on the schema thas holds ducument number

Mit ts-Mungo-Paginierung

    const trainers = await Trainer.paginate(
        { user: req.userId },
        {
            perPage: 3,
            page: 1,
            select: '-password, -createdAt -updatedAt -__v',
            sort: { createdAt: -1 },
        }
    )

    return res.status(200).json(trainers)

let page,limit,skip,lastPage, query;
 page = req.params.page *1 || 1;  //This is the page,fetch from the server
 limit = req.params.limit * 1 || 1; //  This is the limit ,it also fetch from the server
 skip = (page - 1) * limit;   // Number of skip document
 lastPage = page * limit;   //last index 
 counts = await userModel.countDocuments() //Number of document in the collection

query = query.skip(skip).limit(limit) //current page

const paginate = {}

//For previous page
if(skip > 0) {
   paginate.prev = {
       page: page - 1,
       limit: limit
} 
//For next page
 if(lastPage < counts) {
  paginate.next = {
     page: page + 1,
     limit: limit
}
results = await query //Here is the final results of the query.

Konnte auch mit async / await Ergebnisse erzielen.

Codebeispiel unten mit einem asynchronen Handler mit Hapi v17 und Mungo v5

{
            method: 'GET',
            path: '/api/v1/paintings',
            config: {
                description: 'Get all the paintings',
                tags: ['api', 'v1', 'all paintings']
            },
            handler: async (request, reply) => {
                /*
                 * Grab the querystring parameters
                 * page and limit to handle our pagination
                */
                var pageOptions = {
                    page: parseInt(request.query.page) - 1 || 0, 
                    limit: parseInt(request.query.limit) || 10
                }
                /*
                 * Apply our sort and limit
                */
               try {
                    return await Painting.find()
                        .sort({dateCreated: 1, dateModified: -1})
                        .skip(pageOptions.page * pageOptions.limit)
                        .limit(pageOptions.limit)
                        .exec();
               } catch(err) {
                   return err;
               }

            }
        }