如何在 Mongoose 中更新/插入文档？

Question

也许是时候了，也许是我淹没在稀疏的文档中，无法理解 Mongoose 中更新的概念:)

这是交易：

我有一个联系模式和模型（缩短的属性）：

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

var mongooseTypes = require("mongoose-types"),
    useTimestamps = mongooseTypes.useTimestamps;


var ContactSchema = new Schema({
    phone: {
        type: String,
        index: {
            unique: true,
            dropDups: true
        }
    },
    status: {
        type: String,
        lowercase: true,
        trim: true,
        default: 'on'
    }
});
ContactSchema.plugin(useTimestamps);
var Contact = mongoose.model('Contact', ContactSchema);

我收到来自客户的请求，其中包含我需要的字段并因此使用我的模型：

mongoose.connect(connectionString);
var contact = new Contact({
    phone: request.phone,
    status: request.status
});

现在我们遇到了问题：

1. 如果我拨打contact.save(function(err){...})如果具有相同电话号码的联系人已经存在（如预期 - 唯一），我将收到错误
2. 我无法在联系人中调用update() ，因为文档中不存在该方法
3. 如果我调用模型的更新：
   Contact.update({phone:request.phone}, contact, {upsert: true}, function(err{...})
   我进入了某种无限循环，因为 Mongoose 更新实现显然不想要一个对象作为第二个参数。
4. 如果我也这样做，但在第二个参数中，我传递了一个请求属性的关联数组{status: request.status, phone: request.phone ...}它可以工作 - 但是我没有参考特定联系人和无法找出其createdAt和updatedAt性能。

所以最重要的是，毕竟我尝试过：给定一个文档contact ，如果它存在，我该如何更新它，或者如果它不存在，我如何添加它？

谢谢你的时间。

Answer 1

Mongoose 现在通过findOneAndUpdate （调用 MongoDB findAndModify ）原生支持这一点。

如果对象不存在， upsert = true 选项会创建该对象。 默认为 false 。

var query = {'username': req.user.username};
req.newData.username = req.user.username;

MyModel.findOneAndUpdate(query, req.newData, {upsert: true}, function(err, doc) {
    if (err) return res.send(500, {error: err});
    return res.send('Succesfully saved.');
});

---

在旧版本中，Mongoose 不支持使用此方法的这些钩子：

• 默认值
• 二传手
• 验证器
• 中间件

Answer 2

我刚刚花了 3 个小时试图解决同样的问题。 具体来说，我想“替换”整个文档（如果存在），或者以其他方式插入。 这是解决方案：

var contact = new Contact({
  phone: request.phone,
  status: request.status
});

// Convert the Model instance to a simple object using Model's 'toObject' function
// to prevent weirdness like infinite looping...
var upsertData = contact.toObject();

// Delete the _id property, otherwise Mongo will return a "Mod on _id not allowed" error
delete upsertData._id;

// Do the upsert, which works like this: If no Contact document exists with 
// _id = contact.id, then create a new doc using upsertData.
// Otherwise, update the existing doc with upsertData
Contact.update({_id: contact.id}, upsertData, {upsert: true}, function(err{...});

我在Mongoose 项目页面上创建了一个问题，要求将有关此的信息添加到文档中。

Answer 3

你很亲近

Contact.update({phone:request.phone}, contact, {upsert: true}, function(err){...})

但是你的第二个参数应该是一个带有修改运算符的对象，例如

Contact.update({phone:request.phone}, {$set: { phone: request.phone }}, {upsert: true}, function(err){...})

Answer 4

好吧，我等了很长时间，没有回答。 最终放弃了整个更新/upsert方法并采用：

ContactSchema.findOne({phone: request.phone}, function(err, contact) {
    if(!err) {
        if(!contact) {
            contact = new ContactSchema();
            contact.phone = request.phone;
        }
        contact.status = request.status;
        contact.save(function(err) {
            if(!err) {
                console.log("contact " + contact.phone + " created at " + contact.createdAt + " updated at " + contact.updatedAt);
            }
            else {
                console.log("Error: could not save contact " + contact.phone);
            }
        });
    }
});

它有效吗？ 是的。 我对此满意吗？ 可能不是。 2 个 DB 调用而不是一个。
希望未来的 Mongoose 实现能够提供Model.upsert函数。

Answer 5

我是猫鼬的维护者。 更新插入文档的更现代方法是使用Model.updateOne()函数。

await Contact.updateOne({
    phone: request.phone
}, { status: request.status }, { upsert: true });

如果你需要更新的文档，你可以使用Model.findOneAndUpdate()

const doc = await Contact.findOneAndUpdate({
    phone: request.phone
}, { status: request.status }, { upsert: true, useFindAndModify: false });

关键在于您需要将filter参数中的唯一属性放入updateOne()或findOneAndUpdate() ，并将其他属性放入update参数中。

这是有关使用 Mongoose 插入文档的教程。

Answer 6

您可以通过使用承诺链来实现非常优雅的解决方案：

app.put('url', (req, res) => {

    const modelId = req.body.model_id;
    const newName = req.body.name;

    MyModel.findById(modelId).then((model) => {
        return Object.assign(model, {name: newName});
    }).then((model) => {
        return model.save();
    }).then((updatedModel) => {
        res.json({
            msg: 'model updated',
            updatedModel
        });
    }).catch((err) => {
        res.send(err);
    });
});

Answer 7

我创建了一个 StackOverflow 帐户只是为了回答这个问题。 在网上搜索无果后，我只是自己写了一些东西。 我就是这样做的，因此它可以应用于任何猫鼬模型。 导入此函数或将其直接添加到您进行更新的代码中。

function upsertObject (src, dest) {

  function recursiveFunc (src, dest) {
    _.forOwn(src, function (value, key) {
      if(_.isObject(value) && _.keys(value).length !== 0) {
        dest[key] = dest[key] || {};
        recursiveFunc(src[key], dest[key])
      } else if (_.isArray(src) && !_.isObject(src[key])) {
          dest.set(key, value);
      } else {
        dest[key] = value;
      }
    });
  }

  recursiveFunc(src, dest);

  return dest;
}

然后要更新 mongoose 文档，请执行以下操作，

YourModel.upsert = function (id, newData, callBack) {
  this.findById(id, function (err, oldData) {
    if(err) {
      callBack(err);
    } else {
      upsertObject(newData, oldData).save(callBack);
    }
  });
};

此解决方案可能需要 2 个 DB 调用，但您确实可以从中受益，

• 对您的模型进行模式验证，因为您使用的是 .save()
• 您无需在更新调用中手动枚举即可插入深度嵌套的对象，因此如果您的模型发生更改，您不必担心更新您的代码

请记住，即使源具有现有值，目标对象也将始终覆盖源

此外，对于数组，如果现有对象的数组比替换它的数组长，则旧数组末尾的值将保留。 向上插入整个数组的一种简单方法是在向上插入之前将旧数组设置为空数组，如果这是您打算执行的操作。

更新 - 2016 年 1 月 16 日我添加了一个额外的条件，如果存在原始值数组，Mongoose 不会在不使用“set”函数的情况下实现数组更新。

Answer 8

我需要将文档更新/插入到一个集合中，我所做的是创建一个新的对象文字，如下所示：

notificationObject = {
    user_id: user.user_id,
    feed: {
        feed_id: feed.feed_id,
        channel_id: feed.channel_id,
        feed_title: ''
    }
};

由我从数据库中其他地方获取的数据组成，然后在模型上调用更新

Notification.update(notificationObject, notificationObject, {upsert: true}, function(err, num, n){
    if(err){
        throw err;
    }
    console.log(num, n);
});

这是我第一次运行脚本后得到的输出：

1 { updatedExisting: false,
    upserted: 5289267a861b659b6a00c638,
    n: 1,
    connectionId: 11,
    err: null,
    ok: 1 }

这是我第二次运行脚本时的输出：

1 { updatedExisting: true, n: 1, connectionId: 18, err: null, ok: 1 }

我正在使用猫鼬版本 3.6.16

Answer 9

app.put('url', function(req, res) {

        // use our bear model to find the bear we want
        Bear.findById(req.params.bear_id, function(err, bear) {

            if (err)
                res.send(err);

            bear.name = req.body.name;  // update the bears info

            // save the bear
            bear.save(function(err) {
                if (err)
                    res.send(err);

                res.json({ message: 'Bear updated!' });
            });

        });
    });

这里有一个更好的方法来解决mongoose 中的更新方法，您可以查看Scotch.io以获取更多详细信息。 这绝对对我有用！！！

Answer 10

2.6 中引入了一个错误，也会影响到 2.7

upsert 用于在 2.4 上正常工作

https://groups.google.com/forum/#!topic/mongodb-user/UcKvx4p4hnY https://jira.mongodb.org/browse/SERVER-13843

看一看，里面有一些重要的信息

更新：

这并不意味着 upsert 不起作用。 这是如何使用它的一个很好的例子：

User.findByIdAndUpdate(userId, {online: true, $setOnInsert: {username: username, friends: []}}, {upsert: true})
    .populate('friends')
    .exec(function (err, user) {
        if (err) throw err;
        console.log(user);

        // Emit load event

        socket.emit('load', user);
    });

Answer 11

您可以简单地使用此更新记录并获取更新的数据作为响应

router.patch('/:id', (req, res, next) => {
    const id = req.params.id;
    Product.findByIdAndUpdate(id, req.body, {
            new: true
        },
        function(err, model) {
            if (!err) {
                res.status(201).json({
                    data: model
                });
            } else {
                res.status(500).json({
                    message: "not found any relative data"
                })
            }
        });
});

Answer 12

这对我有用。

 app.put('/student/:id', (req, res) => { Student.findByIdAndUpdate(req.params.id, req.body, (err, user) => { if (err) { return res .status(500) .send({error: "unsuccessful"}) }; res.send({success: "success"}); }); });

Answer 13

这是创建/更新同时调用中间件和验证器的最简单方法。

Contact.findOne({ phone: request.phone }, (err, doc) => {
    const contact = (doc) ? doc.set(request) : new Contact(request);

    contact.save((saveErr, savedContact) => {
        if (saveErr) throw saveErr;
        console.log(savedContact);
    });
})

Answer 14

对于到达这里仍然在寻找带有钩子支持的“upsert”的良好解决方案的任何人，这就是我已经测试和工作的。 它仍然需要 2 个 DB 调用，但比我在单个调用中尝试过的任何方法都要稳定得多。

// Create or update a Person by unique email.
// @param person - a new or existing Person
function savePerson(person, done) {
  var fieldsToUpdate = ['name', 'phone', 'address'];

  Person.findOne({
    email: person.email
  }, function(err, toUpdate) {
    if (err) {
      done(err);
    }

    if (toUpdate) {
      // Mongoose object have extra properties, we can either omit those props
      // or specify which ones we want to update.  I chose to update the ones I know exist
      // to avoid breaking things if Mongoose objects change in the future.
      _.merge(toUpdate, _.pick(person, fieldsToUpdate));
    } else {      
      toUpdate = person;
    }

    toUpdate.save(function(err, updated, numberAffected) {
      if (err) {
        done(err);
      }

      done(null, updated, numberAffected);
    });
  });
}

Answer 15

如果生成器可用，它会变得更加容易：

var query = {'username':this.req.user.username};
this.req.newData.username = this.req.user.username;
this.body = yield MyModel.findOneAndUpdate(query, this.req.newData).exec();

Answer 16

没有其他解决方案对我有用。 我正在使用发布请求并更新数据（如果发现），则插入它，_id 也与需要删除的请求正文一起发送。

router.post('/user/createOrUpdate', function(req,res){
    var request_data = req.body;
    var userModel = new User(request_data);
    var upsertData = userModel.toObject();
    delete upsertData._id;

    var currentUserId;
    if (request_data._id || request_data._id !== '') {
        currentUserId = new mongoose.mongo.ObjectId(request_data._id);
    } else {
        currentUserId = new mongoose.mongo.ObjectId();
    }

    User.update({_id: currentUserId}, upsertData, {upsert: true},
        function (err) {
            if (err) throw err;
        }
    );
    res.redirect('/home');

});

Answer 17

按照Traveling Tech Guy的回答，这已经很棒了，我们可以创建一个插件，并在初始化.upsert()其附加到.upsert() ，以便.upsert()将在所有模型上可用。

插件.js

export default (schema, options) => {
  schema.statics.upsert = async function(query, data) {
    let record = await this.findOne(query)
    if (!record) {
      record = new this(data)
    } else {
      Object.keys(data).forEach(k => {
        record[k] = data[k]
      })
    }
    return await record.save()
  }
}

数据库.js

import mongoose from 'mongoose'

import Plugins from './plugins'

mongoose.connect({ ... })
mongoose.plugin(Plugins)

export default mongoose

然后，您可以随时执行User.upsert({ _id: 1 }, { foo: 'bar' })或YouModel.upsert({ bar: 'foo' }, { value: 1 }) 。

Answer 18

ContactSchema.connection.findOne({phone: request.phone}, function(err, contact) {
    if(!err) {
        if(!contact) {
            contact = new ContactSchema();
            contact.phone = request.phone;
        }
        contact.status = request.status;
        contact.save(function(err) {
            if(!err) {
                console.log("contact " + contact.phone + " created at " + contact.createdAt + " updated at " + contact.updatedAt);
            }
            else {
                console.log("Error: could not save contact " + contact.phone);
            }
        });
    }
});

Answer 19

//Here is my code to it... work like ninj

router.param('contractor', function(req, res, next, id) {
  var query = Contractors.findById(id);

  query.exec(function (err, contractor){
    if (err) { return next(err); }
    if (!contractor) { return next(new Error("can't find contractor")); }

    req.contractor = contractor;
    return next();
  });
});

router.get('/contractors/:contractor/save', function(req, res, next) {

    contractor = req.contractor ;
    contractor.update({'_id':contractor._id},{upsert: true},function(err,contractor){
       if(err){ 
            res.json(err);
            return next(); 
            }
    return res.json(contractor); 
  });
});


--

Answer 20

过了一会儿我才回到这个问题，并决定根据 Aaron Mast 的回答发布一个插件。

https://www.npmjs.com/package/mongoose-recursive-upsert

将其用作猫鼬插件。 它设置了一个静态方法，该方法将递归合并传入的对象。

Model.upsert({unique: 'value'}, updateObject});

Answer 21

User.findByIdAndUpdate(req.param('userId'), req.body, (err, user) => {
    if(err) return res.json(err);

    res.json({ success: true });
});

Answer 22

这个咖啡脚本适用于我的 Node - 诀窍是当从客户端发送和返回时，_id 被剥离了它的 ObjectID 包装器，因此需要替换它以进行更新（当没有提供 _id 时，保存将恢复为插入和添加一）。

app.post '/new', (req, res) ->
    # post data becomes .query
    data = req.query
    coll = db.collection 'restos'
    data._id = ObjectID(data._id) if data._id

    coll.save data, {safe:true}, (err, result) ->
        console.log("error: "+err) if err
        return res.send 500, err if err

        console.log(result)
        return res.send 200, JSON.stringify result

Answer 23

以 Martin Kuzdowicz 上面发布的内容为基础。 我使用以下内容使用 mongoose 和 json 对象的深度合并进行更新。 与 mongoose 中的 model.save() 函数一起，这允许 mongoose 进行完整的验证，即使是依赖于 json 中的其他值的验证。 它确实需要 deepmerge 包https://www.npmjs.com/package/deepmerge 。 但这是一个非常轻的包装。

var merge = require('deepmerge');

app.put('url', (req, res) => {

    const modelId = req.body.model_id;

    MyModel.findById(modelId).then((model) => {
        return Object.assign(model, merge(model.toObject(), req.body));
    }).then((model) => {
        return model.save();
    }).then((updatedModel) => {
        res.json({
            msg: 'model updated',
            updatedModel
        });
    }).catch((err) => {
        res.send(err);
    });
});

Answer 24

阅读完上面的帖子后，我决定使用以下代码：

    itemModel.findOne({'pid':obj.pid},function(e,r){
        if(r!=null)
        {
             itemModel.update({'pid':obj.pid},obj,{upsert:true},cb);
        }
        else
        {
            var item=new itemModel(obj);
            item.save(cb);
        }
    });

如果 r 为空，我们创建新项目。 否则，请在更新中使用 upsert，因为更新不会创建新项目。