Node.jsでMongooseをページングする方法は?


232

Node.jsとmongooseを使用してwebappを作成しています。.find()通話から得られた結果にどのようにページ番号を付けることができますか?"LIMIT 50,100"SQLに匹敵する機能が欲しいのですが。


コレクションからデータを検索するときに、スキッププロパティと制限プロパティを使用します。
アルンサハニ2017

このリンクは詳細に使用される場合があります。laxmanchavda.blogspot.com/2018/06/...
laxman

回答:


278

私はこの質問で受け入れられた答えに非常に失望しています。これはスケーリングしません。cursor.skip()の細字を読んだ場合:

cursor.skip()メソッドは、結果を返す前に、サーバーがコレクションまたはインデックスの先頭から移動してオフセットまたはスキップ位置を取得する必要があるため、コストがかかることがよくあります。オフセット(上記のpageNumberなど)が増加すると、cursor.skip()は遅くなり、CPUを集中的に使用します。大きなコレクションでは、cursor.skip()がIOバインドになる可能性があります。

スケール可能な方法でページ分割を実現するには、limit()と少なくとも1つのフィルター基準を組み合わせて、createdOn日付が多くの目的に適しています。

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

105
しかし、スキップせずにそのクエリからページ2を取得するにはどうすればよいでしょうか。ページあたり10件の結果を表示していて、100件の結果がある場合、オフセットまたはスキップ値をどのように定義しますか?あなたはページネーションの質問に答えていないので、それは有効な注意ですが、「がっかり」することはできません。MySQLのオフセットにも同じ問題がありますが、制限があります。結果を返す前に、ツリーをオフセットまでトラバースする必要があります。結果セットが1mil未満で、保持可能なパフォーマンスヒットがない場合は、これを細かく調整して、skip()を使用します。
Lex

13
私はそれは、それはマングース/ MongoDBのことになるとのnoobだけど、レックスの質問に答えるために表示される結果は「で注文されているとして、それを-createdOnあなたが値を置き換えるだろう」request.createdOnBeforeの最小値とcreatedOn、前回の結果セットに返さ次に再クエリします。
Terry Lewis、

9
@JoeFrambach createdOnに基づくリクエストは問題があるようです。スキップは理由により埋め込まれました。ドキュメントは、すべてのDBMSに当てはまる、btreeインデックスの循環によるパフォーマンスヒットの警告のみです。ユーザーの質問には、「MySQLがLIMIT 50,100に匹敵する何か」という.skipがぴったりです。
Lex

8
興味深いことですが、@ Lexのコメントにあるように、この回答の問題は、結果を「進む」または「戻る」しかスキップできないことです。ジャンプできる「ページ」を含めることはできません(例:ページ1、ページ2)。 、ページ3)ページ付けの開始位置を特定するために複数の順次クエリを作成せずに、ほとんどの場合、スキップを使用するよりも遅くなると思います。もちろん、特定のページにスキップする機能を追加する必要がない場合もあります。
Iain Collins

20
この回答には興味深い点が含まれていますが、元の質問に対する回答にはなりません。
2015

227

Rodolpheから提供された情報を使用してMongoose APIを詳しく調べた後、私はこの解決策を見つけました。

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

21
「カウント」はどうですか?そこに何ページあるかを知る必要があります。
Aleksey Saatchi 14

36
スケーリングしません。
Chris Hinkle

4
これがスケーリングしない理由を説明するChris Hinkleの説明:stackoverflow.com/a/23640287/165330
imme 2014年

7
@ChrisHinkleこれは、すべてのDBMSに当てはまるようです。リンクされた回答の下のレックスのコメントは、より多くを説明しているようです。
csotiriou 2014年

2
@Avijええ。そのために識別子を使用しました。そこで行うのは、最後のレコードIDをサーバーに送り返し、送信されたIDよりも大きいIDを持ついくつかのレコードを取得することです。Idはそのようにインデックス付けされるため、はるかに速くなります
ジョージベイリー

108

マングース、エクスプレス、ジェイドを使用したページ分割-詳細はこちらのブログへのリンクです

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

26
回答を投稿していただきありがとうございます。セルフプロモーションに関するFAQをよくお読みください。また、独自のサイト/製品にリンクするたびに免責事項を投稿する必要があることにも注意してください。
Andrew Barber

Math.max(0, undefined)戻りますundefined、これは私のために働きました:let limit = Math.abs(req.query.limit) || 10; let page = (Math.abs(req.query.page) || 1) - 1; Schema.find().limit(limit).skip(limit * page)
Monfa.red

55

あなたはそのように連鎖することができます:

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

を使用してクエリを実行します exec

query.exec(callback);

回答ありがとうございます。これに結果が追加されたコールバックはどうですか?
トーマス

2
execFind(function(...例: var page = req.param('p'); var per_page = 10; if (page == null) { page = 0; } Location.count({}, function(err, count) { Location.find({}).skip(page*per_page).limit(per_page).execFind(function(err, locations) { res.render('index', { locations: locations }); }); });
todd

9
注:これはでは動作しませんマングースが、それはMongoDBのネイティブ・ドライバで動作します。
ジェシー、

39

この場合、クエリpagelimitクエリ文字列としてURLに追加できます。

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

これはaになるので、計算のためStringにaに変換する必要がありNumberます。parseIntメソッドを使用してそれを実行し、いくつかのデフォルト値も提供しましょう。

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

ところで、 ページネーションは0


5
`{ページを追加してください:parseInt(req.query.page)|| 0、...}をパラメーターに追加します。
imalik8088 2017

@ imalik8088ありがとうございます。ただし、AFAIK文字列パラメータはによって自動的に処理されmongooseます。
CENT1PEDE 2017

1
動作を期待していましたが、私の場合、それを
隠す

@ imalik8088それは変だ。多分あなたが再現エラーを示すことができれば私は私の答えを編集することができます。ありがとう。
CENT1PEDE 2017

2
これは条件を適用する前にマングースにすべてのレコードを見つけさせるでしょうか?
FluffyBe

37

あなたはそれを簡単にするMongoose Paginateと呼ばれる小さなパッケージを使うことができます。

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

2
これは最適化されていますか?
アルジェント

16

これはあなたがこれを試すことができるサンプルの例です、

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

11

ページングにマングース関数を使用してみてください。制限は、ページあたりのレコード数とページ数です。

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

10

これは私がコードでそれをやったことです

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

それは私がそれをした方法です。


1
ページの総数を取得する方法
ルシケシュ2016年

こんにちは@ Rhushikesh、count()関数を使用してカウントを取得できます。しかし、それはデータベースからの別のクエリである必要があるようです。詳細はこちらmongoosejs.com/docs/api.html#model_Model.count
インドラサントーサ

@Rhushikeshはカウントを取得し、それを制限で除算します
16

count()廃止予定です。使用countDocuments()
Ruslan

7

クエリ;
search = productName、

パラメータ;
ページ= 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);
    });
});

この回答をありがとうございます。最近のスレッドなので、スレッドを読んだ後、最初に試してみました。しかし、それを実装したときにバグを発見しました-現在記述されているように、常にスキップ値があるため、結果の最初のページが返されることはありません。Product.find()呼び出しの前に "page = page-1"を追加してみてください。
Interog

6

これは、すべてのモデルに添付するバージョンです。利便性はアンダースコアに依存し、パフォーマンスは非同期に依存します。optsでは、mongoose構文を使用してフィールドの選択と並べ替えが可能です。

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;

6

シンプルで強力なページネーションソリューション

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:取得する最後のドキュメントID

no_of_docs_required:取得するドキュメントの数、つまり5、10、50など

  1. last_doc_idメソッドにを提供しない場合、IE 5の最新のドキュメントを取得します
  2. あなたが提供したlast_doc_id場合は、次の5つのドキュメントを取得します。

5

上記の回答は有効です。

約束ではなく非同期待ち受けをしている人のための単なるアドオン!!

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

4

次のコード行も使用できます

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

このコードはmongoの最新バージョンで動作します


3

これを実装する確かなアプローチは、クエリ文字列を使用してフロントエンドから値を渡すことです。我々は取得したいとしましょうページ #2をしても制限への出力を25の結果
クエリ文字列は次のようになります。?page=2&limit=25 // this would be added onto your URL: http:localhost:5000?page=2&limit=25

コードを見てみましょう:

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

このロジックをミドルウェアに実装して、さまざまなルート/コントローラーで使用できるようにすることをお勧めします。


2

最も簡単で迅速な方法は、objectIdの例を使用してページ分割することです。

初期荷重状態

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

2

最良のアプローチ(IMO)は、スキップを使用して、限られたコレクションまたはドキュメント内でBUTを制限することです。

限られたドキュメント内でクエリを作成するには、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)

2

ページネーション用の最も簡単なプラグイン。

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

このプラグインはマングースv5.5.5で壊れています
Isaac Pak

1

これは、ページネーションと制限オプションを含むスキルモデルの結果を取得するための関数の例です。

 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

}


0

このようなクエリを書くことができます。

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

page:リクエストパラメータとしてクライアントから送られるページ番号。
per_page:ページごとに表示される結果の数

MEANスタックを使用している場合は、次のブログ投稿で、angular-UIブートストラップを使用してフロントエンドでページ分割を作成し、バックエンドでmongooseスキップおよび制限メソッドを使用するための情報の多くを提供しています。

参照してください:https : //techpituwa.wordpress.com/2015/06/06/mean-js-pagination-with-angular-ui-bootstrap/


0

skip()とlimit()のどちらかを使用できますが、非常に非効率的です。より良い解決策は、インデックス付きフィールドとlimit()での並べ替えです。Wunderflatsの私たちはここに小さなlibを公開しています:https : //github.com/wunderflats/goosepage これは最初の方法を使用します。


0

mongooseをRESTful APIのソースとして使用している場合は、「restify-mongoose」とそのクエリを確認してください。まさにこの機能が組み込まれています。

コレクションに対するクエリは、ここで役立つヘッダーを提供します

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

したがって、基本的には、コレクションへのクエリの読み込み時間が比較的直線的な汎用サーバーが得られます。これはすばらしいことであり、独自の実装に進みたい場合に検討する必要があります。


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

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

    });
}

0

このシンプルなプラグインを使用してください。

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

取り付け

npm install mongoose-paginate-v2
使用法プラグインをスキーマに追加してから、モデルpaginateメソッドを使用します。

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


このプラグインは、別の回答ですでに「推奨」されています。また、あなたがこのパッケージの寄稿者であるかどうかを知ることも役に立ちます。
lukas_o

@lukas_oはい。私はプラグインの作成者です。
Aravind NC、

0

による

クリス・ヒンクル

回答:

//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

0

ts-mongoose-paginationの使用

    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)

0
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.

-1

async / awaitでも結果を得ることができました。

hapi v17とmongoose 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;
               }

            }
        }
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.