web-dev-qa-db-ja.com

mongooseを使用したMongoDBでの一括アップサート

Mongooseで一括アップサートを実行するオプションはありますか？基本的に配列を持ち、存在しない場合は各要素を挿入し、存在する場合は更新しますか？ （税関_idsを使用しています）

。insertを使用すると、MongoDBは重複キー（更新する必要がある）に対してエラーE11000を返します。ただし、複数の新しいドキュメントを挿入しても正常に機能します。

var Users = self.db.collection('Users');

Users.insert(data, function(err){
            if (err) {
                callback(err);
            }
            else {
                callback(null);
            }
        });

。saveを使用すると、パラメーターが単一のドキュメントでなければならないというエラーが返されます。

Users.save(data, function(err){
   ...
}

この回答 はそのようなオプションがないことを示唆していますが、C＃に固有であり、すでに3歳です。だから私はマングースを使用してそれを行うためのオプションがあるかどうか疑問に思っていましたか？

ありがとうございました！

javascriptnode.jsmongodbmongoosemongodb-query
27
user3122267

具体的には「マングース」ではなく、少なくとも執筆時点ではまだ。 2.6リリースのMongoDBシェルでは、一般的なヘルパーメソッドのすべてと同様に、実際には "バルクオペレーションAPI" "内部"を使用しています。その実装では、最初にこれを実行しようとします。古いバージョンのサーバーが検出された場合、レガシー実装への「フォールバック」があります。

すべてのマングースメソッドは、「現在」「レガシー」実装または書き込み懸念応答と基本的なレガシーメソッドを使用しています。しかし、.collection基本的に、mongooseが実装されている基になる「ノードネイティブドライバー」から「コレクションオブジェクト」にアクセスする、指定されたmongooseモデルのアクセサー：

 var mongoose = require('mongoose'),
     Schema = mongoose.Schema;

 mongoose.connect('mongodb://localhost/test');

 var sampleSchema  = new Schema({},{ "strict": false });

 var Sample = mongoose.model( "Sample", sampleSchema, "sample" );

 mongoose.connection.on("open", function(err,conn) { 

    var bulk = Sample.collection.initializeOrderedBulkOp();
    var counter = 0;

    // representing a long loop
    for ( var x = 0; x < 100000; x++ ) {

        bulk.find(/* some search */).upsert().updateOne(
            /* update conditions */
        });
        counter++;

        if ( counter % 1000 == 0 )
            bulk.execute(function(err,result) {             
                bulk = Sample.collection.initializeOrderedBulkOp();
            });
    }

    if ( counter % 1000 != 0 )
        bulk.execute(function(err,result) {
           // maybe do something with result
        });

 });

主な問題は、「マングースメソッド」が実際に接続がまだ実際に確立されていない可能性があることを認識しており、これが完了するまで「キュー」になることです。 「掘り下げ」ているネイティブドライバーは、この区別を行いません。

そのため、接続が何らかの方法または形式で確立されることを本当に意識する必要があります。ただし、実行していることに注意を払っている限り、ネイティブドライバメソッドを使用できます。

22
Neil Lunn

@ neil-lunnが提案したように、制限（1000）を管理する必要はありません。 Mongooseはすでにこれを行っています。この完全なPromiseベースの実装と例の基礎として、彼の素晴らしい答えを使用しました。

var Promise = require('bluebird');
var mongoose = require('mongoose');

var Show = mongoose.model('Show', {
  "id": Number,
  "title": String,
  "provider":  {'type':String, 'default':'eztv'}
});

/**
 * Atomic connect Promise - not sure if I need this, might be in mongoose already..
 * @return {Priomise}
 */
function connect(uri, options){
  return new Promise(function(resolve, reject){
    mongoose.connect(uri, options, function(err){
      if (err) return reject(err);
      resolve(mongoose.connection);
    });
  });
}

/**
 * Bulk-upsert an array of records
 * @param  {Array}    records  List of records to update
 * @param  {Model}    Model    Mongoose model to update
 * @param  {Object}   match    Database field to match
 * @return {Promise}  always resolves a BulkWriteResult
 */
function save(records, Model, match){
  match = match || 'id';
  return new Promise(function(resolve, reject){
    var bulk = Model.collection.initializeUnorderedBulkOp();
    records.forEach(function(record){
      var query = {};
      query[match] = record[match];
      bulk.find(query).upsert().updateOne( record );
    });
    bulk.execute(function(err, bulkres){
        if (err) return reject(err);
        resolve(bulkres);
    });
  });
}

/**
 * Map function for EZTV-to-Show
 * @param  {Object} show EZTV show
 * @return {Object}      Mongoose Show object
 */
function mapEZ(show){
  return {
    title: show.title,
    id: Number(show.id),
    provider: 'eztv'
  };
}

// if you are  not using EZTV, put shows in here
var shows = []; // giant array of {id: X, title: "X"}

// var eztv = require('eztv');
// eztv.getShows({}, function(err, shows){
//   if(err) return console.log('EZ Error:', err);

//   var shows = shows.map(mapEZ);
  console.log('found', shows.length, 'shows.');
  connect('mongodb://localhost/tv', {}).then(function(db){
    save(shows, Show).then(function(bulkRes){
      console.log('Bulk complete.', bulkRes);
      db.close();
    }, function(err){
        console.log('Bulk Error:', err);
        db.close();
    });
  }, function(err){
    console.log('DB Error:', err);
  });

// });

これには、完了時に接続を閉じ、気になる場合はエラーを表示し、そうでない場合は無視するというボーナスがあります（Promisesのエラーコールバックはオプションです）。これも非常に高速です。これをここに置いて、私の調査結果を共有します。例として、すべてのeztvショーをデータベースに保存する場合は、eztvのコメントを解除できます。

18
konsumer

私はMongooseのプラグインをリリースしました。このプラグインは、Promiseインターフェースで一括アップサート操作を実行する静的upsertManyメソッドを公開します。

基礎となるコレクションで独自の一括操作を初期化するよりもこのプラグインを使用することの追加の利点は、このプラグインがデータを最初にMongooseモデルのデータに変換し、次にアップサートの前にプレーンオブジェクトに戻すことです。これにより、Mongooseスキーマの検証が適用され、データが削除され、生の挿入に適合します。

https://github.com/meanie/mongoose-upsert-manyhttps://www.npmjs.com/package/@meanie/mongoose-upsert-many

それが役に立てば幸い！

3
Adam Reis

Db.collectionにバルクメソッドが表示されていない場合、つまりxxx変数にメソッドがないというエラーが発生している場合：initializeOrderedBulkOp（）

Mongooseバージョンを更新してみてください。どうやら古いバージョンのmongooseは、基盤となるmongoのdb.collectionメソッドのすべてをパススルーしていないようです。

npm install mongoose

私の面倒を見てくれました。

1
zstew

私は最近、eコマースアプリに製品を保存しながらこれを達成する必要がありました。 4時間ごとに10000個のアイテムをアップサートする必要があるため、データベースはタイムアウトしていました。私の1つのオプションは、データベースへの接続中にmongooseでsocketTimeoutMSとconnectTimeoutMSを設定することでしたが、ちょっとハックを感じ、データベースの接続タイムアウトのデフォルトを操作したくありませんでした。また、@ neil lunnによるソリューションは、forループ内でモジュラスを取得する単純な同期アプローチを採用していることがわかります。ここに私の非同期バージョンがあり、私は仕事をはるかに良くすると信じています

let BATCH_SIZE = 500
Array.prototype.chunk = function (groupsize) {
    var sets = [];
    var chunks = this.length / groupsize;

    for (var i = 0, j = 0; i < chunks; i++ , j += groupsize) {
        sets[i] = this.slice(j, j + groupsize);
    }

    return sets;
}

function upsertDiscountedProducts(products) {

    //Take the input array of products and divide it into chunks of BATCH_SIZE

    let chunks = products.chunk(BATCH_SIZE), current = 0

    console.log('Number of chunks ', chunks.length)

    let bulk = models.Product.collection.initializeUnorderedBulkOp();

    //Get the current time as timestamp
    let timestamp = new Date(),

        //Keep track of the number of items being looped
        pendingCount = 0,
        inserted = 0,
        upserted = 0,
        matched = 0,
        modified = 0,
        removed = 0,

        //If atleast one upsert was performed
        upsertHappened = false;

    //Call the load function to get started
    load()
    function load() {

        //If we have a chunk to process
        if (current < chunks.length) {
            console.log('Current value ', current)

            for (let i = 0; i < chunks[current].length; i++) {
                //For each item set the updated timestamp to the current time
                let item = chunks[current][i]

                //Set the updated timestamp on each item
                item.updatedAt = timestamp;

                bulk.find({ _id: item._id })
                    .upsert()
                    .updateOne({
                        "$set": item,

                        //If the item is being newly inserted, set a created timestamp on it
                        "$setOnInsert": {
                            "createdAt": timestamp
                        }
                    })
            }

            //Execute the bulk operation for the current chunk
            bulk.execute((error, result) => {
                if (error) {
                    console.error('Error while inserting products' + JSON.stringify(error))
                    next()
                }
                else {

                    //Atleast one upsert has happened
                    upsertHappened = true;
                    inserted += result.nInserted
                    upserted += result.nUpserted
                    matched += result.nMatched
                    modified += result.nModified
                    removed += result.nRemoved

                    //Move to the next chunk
                    next()
                }
            })



        }
        else {
            console.log("Calling finish")
            finish()
        }

    }

    function next() {
        current++;

        //Reassign bulk to a new object and call load once again on the new object after incrementing chunk
        bulk = models.Product.collection.initializeUnorderedBulkOp();
        setTimeout(load, 0)
    }

    function finish() {

        console.log('Inserted ', inserted + ' Upserted ', upserted, ' Matched ', matched, ' Modified ', modified, ' Removed ', removed)

        //If atleast one chunk was inserted, remove all items with a 0% discount or not updated in the latest upsert
        if (upsertHappened) {
            console.log("Calling remove")
            remove()
        }


    }

    /**
     * Remove all the items that were not updated in the recent upsert or those items with a discount of 0
     */
    function remove() {

        models.Product.remove(
            {
                "$or":
                [{
                    "updatedAt": { "$lt": timestamp }
                },
                {
                    "discount": { "$eq": 0 }
                }]
            }, (error, obj) => {
                if (error) {
                    console.log('Error while removing', JSON.stringify(error))
                }
                else {
                    if (obj.result.n === 0) {
                        console.log('Nothing was removed')
                    } else {
                        console.log('Removed ' + obj.result.n + ' documents')
                    }
                }
            }
        )
    }
}
0
PirateApp