我一直在使用this mongoose plugin执行代码库中经常使用的 findOrCreate。

我最近意识到，在创建唯一索引时执行多个异步findOrCreate 操作很容易导致E11000 重复键错误。

下面使用 Promise.all 可以描述一个示例。假设 name 是唯一的:

const promises = await Promise.all([
  Pokemon.findOrCreate({ name: 'Pikachu' }),
  Pokemon.findOrCreate({ name: 'Pikachu' }),
  Pokemon.findOrCreate({ name: 'Pikachu' })
]);

上述肯定会失败，因为 findOrCreate 不是原子的。考虑到失败的原因是有道理的，但我想要的是一种解决此问题的简化方法。

我的很多模型都使用了findOrCreate，它们都存在这个问题。我想到的一个解决方案是创建一个插件来捕获错误，然后返回 find 的结果，但是，这里可能有更好的方法 - 可能是我不是的原生 Mongoose 意识到。

最佳答案

这当然取决于您对此的预期用途，但我会说总的来说“插件”不是必需的。您正在寻找的基本功能已经“内置”到 MongoDB 中 "upserts" .

根据定义，只要使用集合的“唯一键”发出“选择”文档的查询条件，“upsert”就不会产生“重复键错误”。在这种情况下 "name"。

简而言之，您可以通过简单地执行以下操作来模仿与上述相同的行为:

let results = await Promise.all([
  Pokemon.findOneAndUpdate({ "name": "Pikachu" },{},{ "upsert": true, "new": true }),
  Pokemon.findOneAndUpdate({ "name": "Pikachu" },{},{ "upsert": true, "new": true }),
  Pokemon.findOneAndUpdate({ "name": "Pikachu" },{},{ "upsert": true, "new": true })
]);

这将在第一次调用时简单地“创建”该项目，而该项目尚不存在，或者“返回”现有项目。这就是“更新插入”的工作方式。

[
  {
    "_id": "5a022f48edca148094f30e8c",
    "name": "Pikachu",
    "__v": 0
  },
  {
    "_id": "5a022f48edca148094f30e8c",
    "name": "Pikachu",
    "__v": 0
  },
  {
    "_id": "5a022f48edca148094f30e8c",
    "name": "Pikachu",
    "__v": 0
  }
]

如果您真的不关心“返回”每个调用而只想“更新或创建”，那么使用 bulkWrite() 发送一个 请求实际上效率要高得多。 :

// Issue a "batch" in Bulk
let result = await Pokemon.bulkWrite(
  Array(3).fill(1).map( (e,i) => ({
    "updateOne": {
      "filter": { "name": "Pikachu" },
      "update": {
        "$set": { "skill": i }
      },
      "upsert": true
    }
  }))
);

因此，您不必等待服务器解析三个异步调用，而只需调用一个，它可以“创建”项目或“更新”您在$set 中使用的任何内容。发现时的修饰符。这些应用于每场比赛，包括第一场比赛，如果您想要“仅在创建时”，则有 $setOnInsert这样做。

当然这只是一个“写”，所以它真的取决于返回修改后的文档对你是否重要。因此，“批量”操作只是“写入”，它们不会返回，而是返回有关“批处理”的信息，指示“更新”的内容和“修改”的内容，如:

{
  "ok": 1,
  "writeErrors": [],
  "writeConcernErrors": [],
  "insertedIds": [],
  "nInserted": 0,
  "nUpserted": 1,           // <-- created 1 time
  "nMatched": 2,            // <-- matched and modified the two other times
  "nModified": 2,
  "nRemoved": 0,
  "upserted": [
    {
      "index": 0,
      "_id": "5a02328eedca148094f30f33"  // <-- this is the _id created in upsert
    }
  ],
  "lastOp": {
    "ts": "6485801998833680390",
    "t": 23
  }
}

所以如果你确实想要“返回”，那么一个更典型的情况是在“创建”时分离你想要的数据和“更新”时需要的数据。注意到 $setOnInsert对于选择文档的“查询”条件中的任何值，本质上都是“隐含的”:

// Issue 3 pokemon as separate calls
let sequence = await Promise.all(
  Array(3).fill(1).map( (e,i) =>
    Pokemon.findOneAndUpdate(
      { name: "Pikachu" },
      { "$set": { "skill": i } },
      { "upsert": true, "new": true }
    )
  )
);

这将显示在每个原子事务的“序列”中应用的修改:

[
  {
    "_id": "5a02328fedca148094f30f38",
    "name": "Pikachu",
    "__v": 0,
    "skill": 0
  },
  {
    "_id": "5a02328fedca148094f30f39",
    "name": "Pikachu",
    "__v": 0,
    "skill": 1
  },
  {
    "_id": "5a02328fedca148094f30f38",
    "name": "Pikachu",
    "__v": 0,
    "skill": 2
  }
]

所以一般来说，您在这里想要的是“upserts”，并且根据您的意图，您可以使用单独的调用来返回每个修改/创建，或者您批量发出“写入”。

作为展示上述所有内容的完整 list :

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

mongoose.Promise = global.Promise;
mongoose.set('debug', true);

const uri = 'mongodb://localhost/test',
      options = { useMongoClient: true };

const pokemonSchema = new Schema({
  name: String,
  skill: Number
},{ autoIndex: false });

pokemonSchema.index({ name: 1 },{ unique: true, background: false });

const Pokemon = mongoose.model('Pokemon', pokemonSchema);

function log(data) {
  console.log(JSON.stringify(data, undefined, 2))
}

(async function() {

  try {

    const conn = await mongoose.connect(uri,options);

    // Await index creation, otherwise we error
    await Pokemon.ensureIndexes();

    // Clean data for test
    await Pokemon.remove();

    // Issue 3 pokemon as separate calls
    let pokemon = await Promise.all(
      Array(3).fill(1).map( e =>
        Pokemon.findOneAndUpdate({ name: "Pikachu" },{},{ "upsert": true, "new": true })
      )
    );

    log(pokemon);

    // Clean data again
    await Pokemon.remove();


    // Issue a "batch" in Bulk
    let result = await Pokemon.bulkWrite(
      Array(3).fill(1).map( (e,i) => ({
        "updateOne": {
          "filter": { "name": "Pikachu" },
          "update": {
            "$set": { "skill": i }
          },
          "upsert": true
        }
      }))
    );

    log(result);

    let allPokemon = await Pokemon.find();
    log(allPokemon);

    // Clean data again
    await Pokemon.remove();

    // Issue 3 pokemon as separate calls
    let sequence = await Promise.all(
      Array(3).fill(1).map( (e,i) =>
        Pokemon.findOneAndUpdate(
          { name: "Pikachu" },
          { "$set": { "skill": i } },
          { "upsert": true, "new": true }
        )
      )
    );

    log(sequence);


  } catch(e) {
    console.error(e);
  } finally {
    mongoose.disconnect();
  }


})()

哪个会产生输出(对于那些懒得自己运行的人):

Mongoose: pokemons.ensureIndex({ name: 1 }, { unique: true, background: false })
Mongoose: pokemons.remove({}, {})
Mongoose: pokemons.findAndModify({ name: 'Pikachu' }, [], { '$setOnInsert': { __v: 0 } }, { upsert: true, new: true, remove: false, fields: {} })
Mongoose: pokemons.findAndModify({ name: 'Pikachu' }, [], { '$setOnInsert': { __v: 0 } }, { upsert: true, new: true, remove: false, fields: {} })
Mongoose: pokemons.findAndModify({ name: 'Pikachu' }, [], { '$setOnInsert': { __v: 0 } }, { upsert: true, new: true, remove: false, fields: {} })
[
  {
    "_id": "5a023461edca148094f30f82",
    "name": "Pikachu",
    "__v": 0
  },
  {
    "_id": "5a023461edca148094f30f82",
    "name": "Pikachu",
    "__v": 0
  },
  {
    "_id": "5a023461edca148094f30f82",
    "name": "Pikachu",
    "__v": 0
  }
]
Mongoose: pokemons.remove({}, {})
Mongoose: pokemons.bulkWrite([ { updateOne: { filter: { name: 'Pikachu' }, update: { '$set': { skill: 0 } }, upsert: true } }, { updateOne: { filter: { name: 'Pikachu' }, update: { '$set': { skill: 1 } }, upsert: true } }, { updateOne: { filter: { name: 'Pikachu' }, update: { '$set': { skill: 2 } }, upsert: true } } ], {})
{
  "ok": 1,
  "writeErrors": [],
  "writeConcernErrors": [],
  "insertedIds": [],
  "nInserted": 0,
  "nUpserted": 1,
  "nMatched": 2,
  "nModified": 2,
  "nRemoved": 0,
  "upserted": [
    {
      "index": 0,
      "_id": "5a023461edca148094f30f87"
    }
  ],
  "lastOp": {
    "ts": "6485804004583407623",
    "t": 23
  }
}
Mongoose: pokemons.find({}, { fields: {} })
[
  {
    "_id": "5a023461edca148094f30f87",
    "name": "Pikachu",
    "skill": 2
  }
]
Mongoose: pokemons.remove({}, {})
Mongoose: pokemons.findAndModify({ name: 'Pikachu' }, [], { '$setOnInsert': { __v: 0 }, '$set': { skill: 0 } }, { upsert: true, new: true, remove: false, fields: {} })
Mongoose: pokemons.findAndModify({ name: 'Pikachu' }, [], { '$setOnInsert': { __v: 0 }, '$set': { skill: 1 } }, { upsert: true, new: true, remove: false, fields: {} })
Mongoose: pokemons.findAndModify({ name: 'Pikachu' }, [], { '$setOnInsert': { __v: 0 }, '$set': { skill: 2 } }, { upsert: true, new: true, remove: false, fields: {} })
[
  {
    "_id": "5a023461edca148094f30f8b",
    "name": "Pikachu",
    "__v": 0,
    "skill": 0
  },
  {
    "_id": "5a023461edca148094f30f8b",
    "name": "Pikachu",
    "__v": 0,
    "skill": 1
  },
  {
    "_id": "5a023461edca148094f30f8b",
    "name": "Pikachu",
    "__v": 0,
    "skill": 2
  }
]

N.B The $setOnInsert is also "implied" in all "mongoose" operations for the purpose of applying the __v key. So unless you turn this off, that statement is always "merged" with whatever is issued and thus allows the {} in the first example "update" block which would be an error in the core driver due to no update modifier being applied, yet mongoose adds this one for you.

Also note that bulkWrite() does not actually reference the "schema" for the model and bypasses it. This is why there is no __v in those issued updates, and it does indeed bypass all validation as well. This is usually not an issue, but it is something you should be aware of.

关于javascript - 使用 Promise.all 避免唯一错误 E11000，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/47164400/