64

我有一个深度嵌套的文档结构，如下所示：

{id: 1, 
 forecasts: [ { 
             forecast_id: 123, 
             name: "Forecast 1", 
             levels: [ 
                { level: "proven", 
                  configs: [
                            { 
                              config: "Custom 1",
                              variables: [{ x: 1, y:2, z:3}]
                            }, 
                            { 
                              config: "Custom 2",
                              variables: [{ x: 10, y:20, z:30}]
                            }, 
                    ]
                }, 
                { level: "likely", 
                  configs: [
                            { 
                              config: "Custom 1",
                              variables: [{ x: 1, y:2, z:3}]
                            }, 
                            { 
                              config: "Custom 2",
                              variables: [{ x: 10, y:20, z:30}]
                            }, 
                    ]
                }
            ]
        }, 
    ]

}

我正在尝试更新集合以插入新配置，如下所示：

newdata =  {
  config: "Custom 1", 
  variables: [{ x: 111, y:2222, z:3333}]
}

我在 mongo ( 在 Python 中) 尝试这样的事情：

db.myCollection.update({"id": 1, 
                        "forecasts.forecast-id": 123, 
                        "forecasts.levels.level": "proven", 
                        "forecasts.levels.configs.config": "Custom 1"
                         },
                         {"$set": {"forecasts.$.levels.$.configs.$": newData}}
                      )

不过，我收到“如果没有包含数组的相应查询字段，则无法应用位置运算符”错误。在 mongo 中执行此操作的正确方法是什么？这是 mongo v2.4.1。

4

11 回答 11

51

不幸的是，您不能对$每个键多次使用运算符，因此您必须对其余部分使用数值。如：

db.myCollection.update({
    "id": 1, 
    "forecasts.forecast-id": 123, 
    "forecasts.levels.level": "proven", 
    "forecasts.levels.configs.config": "Custom 1"
  },
  {"$set": {"forecasts.$.levels.0.configs.0": newData}}
)

MongoDB 对更新嵌套数组的支持很差。因此，如果您需要频繁更新数据，最好避免使用它们，并考​​虑使用多个集合。

一种可能性：创建forecasts自己的集合，并假设您有一组固定的level值，创建level一个对象而不是数组：

{
  _id: 123,
  parentId: 1,
  name: "Forecast 1", 
  levels: {
    proven: { 
      configs: [
        { 
          config: "Custom 1",
          variables: [{ x: 1, y:2, z:3}]
        }, 
        { 
          config: "Custom 2",
          variables: [{ x: 10, y:20, z:30}]
        }, 
      ]
    },
    likely: {
      configs: [
        { 
          config: "Custom 1",
          variables: [{ x: 1, y:2, z:3}]
        }, 
        { 
          config: "Custom 2",
          variables: [{ x: 10, y:20, z:30}]
        }, 
      ]
    }
  }
}

然后您可以使用以下方法更新它：

db.myCollection.update({
    _id: 123,
    'levels.proven.configs.config': 'Custom 1'
  },
  { $set: { 'levels.proven.configs.$': newData }}
)
于 2013-08-11T16:29:05.173 回答
20

设法使用猫鼬解决它：

您只需要知道链中所有子文档的“_id”（猫鼬会自动为每个子文档创建“_id”）。

例如 -

  SchemaName.findById(_id, function (e, data) {
      if (e) console.log(e);
      data.sub1.id(_id1).sub2.id(_id2).field = req.body.something;

      // or if you want to change more then one field -
      //=> var t = data.sub1.id(_id1).sub2.id(_id2);
      //=> t.field = req.body.something;

      data.save();
  });

更多关于mongoose 文档中的子文档 _id 方法。

解释：_id 用于 SchemaName，_id1 用于 sub1，_id2 用于 sub2 - 你可以保持这样的链接。

*您不必使用 findById 方法，但在我看来这似乎是最方便的，因为无论如何您都需要知道 '_id' 的其余部分。

于 2015-03-09T22:35:01.710 回答
15

MongoDB 在 3.5.2 及更高版本中引入了ArrayFilters来解决这个问题。

3.6 版中的新功能。

从 MongoDB 3.6 开始，在更新数组字段时，您可以指定 arrayFilters 来确定要更新的数组元素。

[ https://docs.mongodb.com/manual/reference/method/db.collection.update/#specify-arrayfilters-for-an-array-update-operations][1]

假设架构设计如下：

var ProfileSchema = new Schema({
    name: String,
    albums: [{
        tour_name: String,
        images: [{
            title: String,
            image: String
        }]
    }]
});

创建的文档如下所示：

{
   "_id": "1",
   "albums": [{
            "images": [
               {
                  "title": "t1",
                  "url": "url1"
               },
               {
                  "title": "t2",
                  "url": "url2"
               }
            ],
            "tour_name": "london-trip"
         },
         {
            "images": [.........]: 
         }]
}

假设我想更新图像的“url”。鉴于 - "document id", "tour_name" and "title"

为此更新查询：

Profiles.update({_id : req.body.id},
    {
        $set: {

            'albums.$[i].images.$[j].title': req.body.new_name
        }
    },
    {
        arrayFilters: [
            {
                "i.tour_name": req.body.tour_name, "j.image": req.body.new_name   // tour_name -  current tour name,  new_name - new tour name 
            }]
    })
    .then(function (resp) {
        console.log(resp)
        res.json({status: 'success', resp});
    }).catch(function (err) {
    console.log(err);
    res.status(500).json('Failed');
})
于 2018-01-01T09:24:51.043 回答
5

这是 MongoDB 中的一个非常老的错误

https://jira.mongodb.org/browse/SERVER-831

于 2015-05-23T19:31:44.450 回答
5

我今天遇到了同样的问题，在 google/stackoverflow/github 上进行了大量探索之后，我认为arrayFilters这是解决这个问题的最佳方法。这适用于 mongo 3.6 及更高版本。这个链接终于拯救了我的一天：https ://thecodebarbarian.com/a-nodejs-perspective-on-mongodb-36-array-filters.html

const OrganizationInformationSchema = mongoose.Schema({
user: {
    _id: String,
    name: String
},
organizations: [{
    name: {
        type: String,
        unique: true,
        sparse: true
    },
    rosters: [{
        name: {
            type: String
        },
        designation: {
            type: String
        }
    }]
}]
}, {
    timestamps: true
});

并在 express 中使用 mongoose，更新给定 id 的名册名称。

const mongoose = require('mongoose');
const ControllerModel = require('../models/organizations.model.js');
module.exports = {
// Find one record from database and update.
findOneRosterAndUpdate: (req, res, next) => {
    ControllerModel.updateOne({}, {
        $set: {
            "organizations.$[].rosters.$[i].name": req.body.name
        }
    }, {
        arrayFilters: [
            { "i._id": mongoose.Types.ObjectId(req.params.id) }
        ]
    }).then(response => {
        res.send(response);
    }).catch(err => {
        res.status(500).send({
            message: "Failed! record cannot be updated.",
            err
        });
    });
}
}
于 2019-03-01T14:38:53.327 回答
4

它是固定的。 https://jira.mongodb.org/browse/SERVER-831

但此功能从 MongoDB 3.5.12 开发版本开始可用。

注意：这个问题被问到Aug 11 2013并解决了Aug 11 2017

于 2017-09-01T10:48:00.847 回答
3

鉴于 MongoDB 似乎没有为此提供良好的机制，我发现使用 mongoose 来简单地从 mongo 集合中提取元素是谨慎的做法.findOne(...)，对其相关子元素运行 for 循环搜索（通过说 ObjectID 搜索），修改那个 JSON，然后做Schema.markModified('your.subdocument'); Schema.save();可能效率不高，但是很简单，效果很好。

于 2013-09-12T11:33:22.433 回答
2

我搜索了大约 5 个小时，终于找到了最好和最简单的解决方案： 如何更新 MONGO DB 中的嵌套子文档

{id: 1, 
forecasts: [ { 
         forecast_id: 123, 
         name: "Forecast 1", 
         levels: [ 
            { 
                levelid:1221
                levelname: "proven", 
                configs: [
                        { 
                          config: "Custom 1",
                          variables: [{ x: 1, y:2, z:3}]
                        }, 
                        { 
                          config: "Custom 2",
                          variables: [{ x: 10, y:20, z:30}]
                        }, 
                ]
            }, 
            { 
                levelid:1221
                levelname: "likely", 
                configs: [
                        { 
                          config: "Custom 1",
                          variables: [{ x: 1, y:2, z:3}]
                        }, 
                        { 
                          config: "Custom 2",
                          variables: [{ x: 10, y:20, z:30}]
                        }, 
                ]
            }
        ]
    }, 
]}

询问：

db.weather.updateOne({
                "_id": ObjectId("1"), //this is level O select
                "forecasts": {
                    "$elemMatch": {
                        "forecast_id": ObjectId("123"), //this is level one select
                        "levels.levelid": ObjectId("1221") // this is level to select
                    }
                }
            },
                {
                    "$set": {
                        "forecasts.$[outer].levels.$[inner].levelname": "New proven",
                    }
                },
                {
                    "arrayFilters": [
                        { "outer.forecast_id": ObjectId("123") }, 
                        { "inner.levelid": ObjectId("1221") }
                    ]
                }).then((result) => {
                    resolve(result);
                }, (err) => {
                    reject(err);
                });
于 2020-11-30T08:31:55.880 回答
1

分享我的经验教训。我最近遇到了同样的要求，我需要更新一个嵌套数组项。我的结构如下

  {
    "main": {
      "id": "ID_001",
      "name": "Fred flinstone Inc"
    },
    "types": [
      {
        "typeId": "TYPE1",
        "locations": [
          {
            "name": "Sydney",
            "units": [
              {
                "unitId": "PHG_BTG1"
              }
            ]
          },
          {
            "name": "Brisbane",
            "units": [
              {
                "unitId": "PHG_KTN1"
              },
              {
                "unitId": "PHG_KTN2"
              }
            ]
          }
        ]
      }
    ]
  }

我的要求是在特定单位 [] 中添加一些字段。我的解决方案是首先找到嵌套数组项的索引（比如foundUnitIdx）我使用的两种技术是

  1. 使用 $set 关键字

  2. 使用 [] 语法在 $set 中指定动态字段

                query = {
                "locations.units.unitId": "PHG_KTN2"
            };
            var updateItem = {
                $set: {
                    ["locations.$.units."+ foundUnitIdx]: unitItem
                }
            };
            var result = collection.update(
                query,
                updateItem,
                {
                    upsert: true
                }
            );

希望这对其他人有帮助。:)

于 2017-11-08T23:51:38.860 回答
0

Mongodb 3.2+ 的简单解决方案 https://docs.mongodb.com/manual/reference/method/db.collection.replaceOne/

我有类似的情况并像这样解决了它。我使用的是猫鼬，但它仍然可以在香草 MongoDB 中使用。希望它对某人有用。

const MyModel = require('./model.js')
const query = {id: 1}

// First get the doc
MyModel.findOne(query, (error, doc) => {

    // Do some mutations
    doc.foo.bar.etc = 'some new value'

    // Pass in the mutated doc and replace
    MyModel.replaceOne(query, doc, (error, newDoc) => {
         console.log('It worked!')
    })
}

根据您的用例，您可能可以跳过最初的 findOne()

于 2017-12-24T22:26:00.270 回答
-1

Okkk.we 可以在 mongodb 中更新我们的嵌套子文档。这是我们的模式。

var Post = new mongoose.Schema({
    name:String,
    post:[{
        like:String,
        comment:[{
            date:String,
            username:String,
            detail:{
                time:String,
                day:String
            }
        }]
    }]
})

此架构的解决方案

  Test.update({"post._id":"58206a6aa7b5b99e32b7eb58"},
    {$set:{"post.$.comment.0.detail.time":"aajtk"}},
          function(err,data){
//data is updated
})
于 2016-11-07T12:19:36.510 回答