복붙노트

[MONGODB] 어떻게 Node.js를에서 몽구스와 쪽수를 매기다?

MONGODB

어떻게 Node.js를에서 몽구스와 쪽수를 매기다?

나는 Node.js를하고 몽구스와 웹 애플리케이션을 쓰고 있어요. 어떻게 내가 .find () 호출에서 얻는 결과 페이지를 매기는 할 수 있습니까? 나는 SQL에서 "LIMIT 50100"에 필적하는 기능을하고 싶습니다.

해결법

  1. ==============================

    1.나는 정말이 문제의 허용 답변에 실망하고 있어요. 이 확장되지 않습니다. 당신은) (cursor.skip에 미세 인쇄를 읽을 경우 :

    나는 정말이 문제의 허용 답변에 실망하고 있어요. 이 확장되지 않습니다. 당신은) (cursor.skip에 미세 인쇄를 읽을 경우 :

    확장 가능한 방식으로 페이지 매김을 달성하기 적어도 하나 개의 필터 기준하는 createdOn 날짜 정장 많은 목적과 함께 제한 ()를 결합합니다.

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

    2.Rodolphe에서 제공하는 정보와 몽구스의 API에 대해 자세히 살펴 복용 후, 나는이 솔루션을 알아 낸 :

    Rodolphe에서 제공하는 정보와 몽구스의 API에 대해 자세히 살펴 복용 후, 나는이 솔루션을 알아 낸 :

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

    3.페이지 매김 몽구스를 사용하여 표현하고 옥 - 여기에서 더 자세히 내 블로그에 링크입니다

    페이지 매김 몽구스를 사용하여 표현하고 옥 - 여기에서 더 자세히 내 블로그에 링크입니다

    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
            })
        })
    })
  4. ==============================

    4.당신은 그런 식으로 체인 수 있습니다 :

    당신은 그런 식으로 체인 수 있습니다 :

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

    간부를 사용하여 쿼리를 실행

    query.exec(callback);
  5. ==============================

    5.안하는 것보다 늦게하는 것이 낫다.

    안하는 것보다 늦게하는 것이 낫다.

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

    이 경우 당신은 당신의 HTTP URL에 쿼리 페이지 및 / 또는 제한을 추가 할 수 있습니다. 샘플? 페이지 = 0 제한 = 25

    BTW 페이지 매김은 0으로 시작

  6. ==============================

    6.당신은 쉽게 몽구스 페이지를 매기라는 작은 패키지를 사용할 수 있습니다.

    당신은 쉽게 몽구스 페이지를 매기라는 작은 패키지를 사용할 수 있습니다.

    $ npm install mongoose-paginate

    당신의 경로 나 컨트롤러 후, 단지 추가 :

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

    7.이것은 당신이 시도 할 수있는 샘플 예제입니다

    이것은 당신이 시도 할 수있는 샘플 예제입니다

    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
      });
  });
 });
  8. ==============================

    8.페이지 매기기에 몽구스 기능을 사용해보십시오. 제한 페이지와 페이지 수를 당 레코드 수입니다.

    페이지 매기기에 몽구스 기능을 사용해보십시오. 제한 페이지와 페이지 수를 당 레코드 수입니다.

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

    9.이것은 내가 코드를 할 것입니다

    이것은 내가 코드를 할 것입니다

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

    그게 내가 그것을 한 방법이다.

  10. ==============================

    10.여기에 내 모든 모델에 부착하는 버전입니다. 그것은 성능에 대한 편의와 비동기에 대한 밑줄에 따라 달라집니다. OPTS 필드 선택 및 몽구스 구문을 사용하여 정렬 할 수있다.

    여기에 내 모든 모델에 부착하는 버전입니다. 그것은 성능에 대한 편의와 비동기에 대한 밑줄에 따라 달라집니다. OPTS 필드 선택 및 몽구스 구문을 사용하여 정렬 할 수있다.

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

    모델 스키마에 연결합니다.

    MySchema.statics.findPaginated = findPaginated;
  11. ==============================

    11.위의 대답은 좋은를 보유하고 있습니다.

    위의 대답은 좋은를 보유하고 있습니다.

    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
        });
    }
};
  12. ==============================

    12.당신은뿐만 아니라 다음 코드 줄을 사용할 수 있습니다

    당신은뿐만 아니라 다음 코드 줄을 사용할 수 있습니다

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

    이 코드는 몽고의 최신 버전에서 작동합니다

  13. ==============================

    13.가장 쉽고 더 빠른 방법은 ObjectId가와 PAGINATE입니다 예;

    가장 쉽고 더 빠른 방법은 ObjectId가와 PAGINATE입니다 예;

    초기 부하 조건

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

    응답 데이터에서 첫 번째와 마지막 ObjectId가를 타고

    페이지 다음 조건

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

    페이지 다음 조건

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

    몽구스에서

    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);
});
  14. ==============================

    14.가장 좋은 방법은 (IMO) 생략하고 제한하지만 제한된 컬렉션 또는 문서 내에서 사용하는 것입니다.

    가장 좋은 방법은 (IMO) 생략하고 제한하지만 제한된 컬렉션 또는 문서 내에서 사용하는 것입니다.

    제한 문서 내에서 쿼리를 만들려면, 우리는 DATE 유형 필드에 인덱스와 같은 특정 인덱스를 사용할 수 있습니다. 아래에 그 참조

    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)
  15. ==============================

    15.페이지 매김을위한 가장 쉬운 플러그인.

    페이지 매김을위한 가장 쉬운 플러그인.

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

    스키마 한 후 사용 모델 PAGINATE 방법에 플러그인 추가

    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
  16. ==============================

    16.이 페이지 매김하고 제한 옵션을 기술 모델의 결과를 얻기를 위해 예를 들어 기능입니다

    이 페이지 매김하고 제한 옵션을 기술 모델의 결과를 얻기를 위해 예를 들어 기능입니다

     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

    }

  17. ==============================

    17.간단하고 강력한 매김 솔루션

    간단하고 강력한 매김 솔루션

    last_doc_id : 당신이 얻을 것을 마지막으로 문서 ID

    no_of_docs_required : 문서의 수는 즉 5, 10, 50 등을 가져올 것인지

    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
}
  18. ==============================

    18.이 같은 쿼리를 작성할 수 있습니다.

    이 같은 쿼리를 작성할 수 있습니다.

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

    페이지 : 요청 매개 변수로 클라이언트에서 오는 페이지 번호. per_page : 어떤 결과 한 페이지 당 표시

    당신은 블로그 게시물 다음 MEAN 스택을 사용하는 경우 많은 각도-UI 부트 스트랩을 사용하여 생략하고 백엔드에 제한 방법 몽구스 사용하여 프론트 엔드의 페이지 매김을 만들 수있는 정보를 제공합니다.

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

  19. ==============================

    19.당신이 중 하나를 건너 뛸 수 있습니다 () 및 제한 (),하지만 매우 비효율적이다. 더 나은 솔루션은 인덱스 필드 플러스 한계에 정렬 될 것이다 (). Wunderflats에서 우리는 여기에 작은 lib 디렉토리를 게시 한 : https://github.com/wunderflats/goosepage 그것은 첫 번째 방법을 사용합니다.

    당신이 중 하나를 건너 뛸 수 있습니다 () 및 제한 (),하지만 매우 비효율적이다. 더 나은 솔루션은 인덱스 필드 플러스 한계에 정렬 될 것이다 (). Wunderflats에서 우리는 여기에 작은 lib 디렉토리를 게시 한 : https://github.com/wunderflats/goosepage 그것은 첫 번째 방법을 사용합니다.

  20. ==============================

    20.당신이 편안하고 API의 소스로 몽구스를 사용하는 경우를 보라 'restify - 몽구스'와 쿼리. 그것은 바로이 기능이 내장되어있다.

    당신이 편안하고 API의 소스로 몽구스를 사용하는 경우를 보라 'restify - 몽구스'와 쿼리. 그것은 바로이 기능이 내장되어있다.

    모음에 대한 모든 쿼리는 여기에 도움이되는 헤더를 제공합니다

    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

    그래서 기본적으로 당신은 컬렉션에 쿼리에 대해 상대적으로 선형로드 시간에 일반 서버를 얻을. 그 멋진 그리고 당신은 자신의 구현에 가고 싶은 경우에 볼 수있는 무언가이다.

  21. ==============================

    21.

    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});
            }
        });
});
  22. ==============================

    22.

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

    });
}
  23. ==============================

    23.이 간단한 플러그인을 사용합니다.

    이 간단한 플러그인을 사용합니다.

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

    설치

    NPM 몽구스 - PAGINATE-V2를 설치 용법     스키마 한 후 사용 모델 PAGINATE 방법에 플러그인 추가

    CONST 몽구스는 = ( '몽구스') 요구; CONST mongoosePaginate = ( '몽구스-PAGINATE-V2') 요구; const를 MYSCHEMA = 새로운 mongoose.Schema ({   / * 스키마 정의 * / }); mySchema.plugin (mongoosePaginate); CONST myModel mongoose.model = ( 'SampleModel를'MYSCHEMA); myModel.paginate (). 다음 ({}) // 사용

  24. ==============================

    24.비동기과 결과를 달성 할 수 있었다 /도 기다리고 있습니다.

    비동기과 결과를 달성 할 수 있었다 /도 기다리고 있습니다.

    그러면 동상의 V17와 몽구스 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;
               }

            }
        }

    25. from https://stackoverflow.com/questions/5539955/how-to-paginate-with-mongoose-in-node-js by cc-by-sa and MIT license

'MONGODB' 카테고리의 다른 글

[MONGODB] 사용자 이름과 암호를 사용하여 MongoDB를 확보하는 방법  (0) 2019.12.01
[MONGODB] 일치하는 파이프 라인에서 문서의 집계 $ 조회 총 크기는 최대 문서 크기를 초과  (0) 2019.12.01
[MONGODB] MongoDB를 놓아 내부 어레이  (0) 2019.12.01
[MONGODB] MongoDB의 조건부 $ 합  (0) 2019.12.01
[MONGODB] 어떻게 전화와 몽구스의 배열로 객체의 배열을 밀어?  (0) 2019.12.01
,

티스토리툴바