mongodb - findbyid - ¿Cómo paginar con Mangosta en Node.js?

node express pagination example

Question

Estoy escribiendo una aplicación web con Node.js y mangosta. ¿Cómo puedo paginar los resultados que obtengo de una llamada .find() ? Me gustaría una funcionalidad comparable a "LIMIT 50,100" en SQL.

Answer 1

Aquí hay una versión que adjunto a todos mis modelos. Depende del subrayado para mayor comodidad y de manera asincrónica para el rendimiento. La opción permite la selección y clasificación de campo utilizando la sintaxis de mangosta.

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

Adjúntelo a su esquema de modelo.

MySchema.statics.findPaginated = findPaginated;

Answer 2

Después de echar un vistazo más de cerca a la API Mongoose con la información proporcionada por Rodolphe, descubrí esta solución:

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

Answer 3

El mejor enfoque (IMO) es usar saltar y limitar, PERO dentro de colecciones o documentos limitados.

Para realizar la consulta dentro de documentos limitados, podemos usar un índice específico como índice en un campo de tipo FECHA. Mira eso abajo

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)

Answer 4

Este es un ejemplo de muestra, puedes probar esto,

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

Answer 5

Esto es lo que hice en el código

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

Así es como lo hice.

Answer 6

Estoy muy decepcionado con las respuestas aceptadas en esta pregunta. Esto no se escalará. Si lee la letra pequeña de cursor.skip ():

El método cursor.skip () a menudo es costoso porque requiere que el servidor camine desde el comienzo de la colección o índice para obtener la posición de desplazamiento u omisión antes de comenzar a devolver el resultado. A medida que aumenta el offset (por ejemplo, pageNumber), cursor.skip () se volverá más lento y consumirá más CPU. Con colecciones más grandes, cursor.skip () puede convertirse en IO obligado.

Para lograr la paginación de una manera escalable, combine un límite () junto con al menos un criterio de filtro, una fecha de fecha de creación se adapta a muchos propósitos.

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

Answer 7

Intenta usar la función de mangosta para la paginación. El límite es el número de registros por página y el número de la página.

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

Answer 8

La manera más fácil y más rápida es paginar con el ejemplo objectId;

Condición de carga inicial

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

Tome el primer y último ObjectId de los datos de respuesta

Página siguiente condición

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

Página siguiente condición

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

En mangosta

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

Answer 9

Mejor tarde que nunca.

var pageOptions = {
    page: req.query.page || 0,
    limit: req.query.limit || 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);
    })

En este caso, puede agregar la page consulta y / o el limit a su url http. Muestra ?page=0&limit=25

Por cierto, la paginación comienza con 0

Answer 10

Paginación con mangosta, exprés y jade - http://madhums.me/2012/08/20/pagination-using-mongoose-express-and-jade/

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

Answer 11

Puede escribir una consulta como esta.

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

página: número de página que proviene del cliente como parámetros de solicitud.
por página: no de resultados mostrados por página

Si está utilizando la pila MEAN, la siguiente publicación de blog proporciona mucha de la información para crear una paginación en el front end usando el bootstrap angular UI y el uso de métodos mongoose omitir y limitar en el back-end.

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

Answer 12

Puede usar skip () y limit (), pero es muy ineficiente. Una mejor solución sería una especie en el campo indexado más el límite (). En Wunderflats hemos publicado una pequeña biblioteca aquí: https://github.com/wunderflats/goosepage Utiliza la primera forma.

Answer 13

Puede usar un pequeño paquete llamado Mongoose Paginate que lo hace más fácil.

$ npm install mongoose-paginate

Después en tus rutas o tu controlador, simplemente agrega:

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

Answer 14

Puedes encadenar así:

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

Ejecuta la consulta usando exec

query.exec(callback);

Answer 15

Si está usando mangosta como fuente para una api relajante, eche un vistazo a '' restify-mongoose '' y sus consultas. Tiene exactamente esta funcionalidad incorporada.

Cualquier consulta en una colección proporciona encabezados que son útiles aquí

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

Así que básicamente obtienes un servidor genérico con un tiempo de carga relativamente lineal para consultas a colecciones. Eso es asombroso y algo a considerar si quieres entrar en una implementación propia.

Answer 16

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