Update MongoDB document using JSON

Question

Is there a way to update a complex MongoDB document from C# using JSON? For example, suppose I have the following document:

{
    "name": "John Smith",
    "age": 35,
    "readingList": 
        [{
            "title": "Title1",
            "ISBN": 6246246426724,
            "author": 
                {
                    "name": "James Johnson",
                    "age": 40
                }
        },
        {
            "title": "Title2",
            "ISBN": 3513531513551,
            "author": 
                {
                    "name": "Sam Hill",
                    "age": 20
                }
        }]
}

Now I want to update the age of the second book's author (Sam Hill) from 20 to 21. Suppose I have the following JSON representation:

{
    "readingList": 
        [
        {
            "title": "Title2",
            "author": 
                {
                    "age": 21
                }
        }]
}

Basically the second JSON string is like the first one, minus all the fields and array elements that don't change, except for one field in any array being looked at that uniquely identifies that index. In this case, the "age" field is included since it is being updated with the given value. The "title" field is given to locate the right array element while searching for the field to update. There may also be even more subdocuments and arrays to go through, and the format is not static (it may change at a later time). This is just a simplified example.

Is it possible to pass in something like this to some function and update the correct field that way? Is there something at least similar to this, so I can just pass in some JSON to do the update?

The reason I am looking to do it this way, rather than through simpler means, is because I want to keep track of a history of changes to documents, and if I want to backtrack to an earlier version, I want an easy way to do so that can handle this level of complexity.

UPDATE:

I have some clarifications to make. In this particular scenario I have no way to predict what kinds of changes would need to be made. A change could be made to any field at any time, and that field could be anywhere in the document, possibly at the top level, or within multiple nested subdocuments/arrays. The data we're dealing with is for a separate party that may use it and modify it at will, so we have no control over what they choose to do with it. In addition, there is no fixed schema. The other party could add new fields, including new subdocuments or arrays, or delete them.

The reason I'm asking this question is because I would like to store a history of changes to documents in such a way that I could revert to an older snapshot of the document by applying the changes in reverse. In this case, changing the age from to 20 to 21 would revert the document to an older state (assuming that someone messed with the age beforehand and made it 20, and I wanted to fix it back to 21). Since somebody could make any change they wanted to the system, including to the underlying structure of the data itself, I can't just come up with my own schema, or hardcode a solution that changes specific fields using this specific schema.

In this example, the change in age from 20 to 21 would be from a record in the history whose structure I couldn't predict beforehand. So I am looking for an efficient solution to apply an unpredictable update to a document given a simplified JSON representation of the change to be made.

I am also open to alternatives that don't involve JSON if they are fairly efficient. I brought up JSON because I figured that, given MongoDB's usage of JSON to structure documents, it would make the most sense, and perhaps be superior to something like string manipulation. Another alternative I considered would involve storing the change using some kind of custom dot notation, like this: readingList[ISBN:3513531513551].author.age=21"

This would require me to create a custom function to interpret the string and turn it into something useful though, so it doesn't sound like the best solution.

Answer 1

Hi friend I used below JSON document

{
"_id" : ObjectId("56a99c121f25cc3a3c709151"),
"name" : "John Smith",
"age" : 35,
"readingList" : [ 
    {
        "title" : "Title1",
        "ISBN" : NumberLong(6246246426724),
        "author" : {
            "name" : "James Johnson",
            "age" : 40
        }
    }, 
    {
        "title" : "Title2",
        "ISBN" : NumberLong(3513531513551),
        "author" : {
            "name" : "Sam Hill",
            "age" : "25"
        }
    }
]

}

I just used condition as author name is Sam Hill and execute below query in C# and its work.

IMongoQuery query = Query.And(Query.EQ("name", "John Smith"), Query.EQ("readingList.author.name", "Sam Hill"));
        var result =collection.Update(query,
                    MongoDB.Driver.Builders.Update.Set("readingList.$.author.age", "21"));

Answer 2

In your data mode you need to know the array index of the second document. It is better to model readingList attribute as a map. In following example I used isbn as a map key:

{  
   "id":"123",
   "name":"John Smith",
   "age":35,
   "readingList":{  
      "6246246426724":{  
         "title":"Title1",
         "ISBN":6246246426724,
         "author":{  
            "name":"James Johnson",
            "age":40
         }
      },
      "3513531513551":{  
         "title":"Title2",
         "ISBN":3513531513551,
         "author":{  
            "name":"Sam Hill",
            "age":20
         }
      }
   }
}

In this data model you can access second book directly. For instance by dot notation:

db.authors.update(
  { item: "123" },
  { $set: { "readingList.3513531513551.author.age": 22 } }
)

Unfortunately I do know C# notation for that but should be straight forward.

Answer 3

Actually I would not advise you to choose this kind of data model because in my experience it will get pretty messy. Still, you might have some very specific requirements which might force you to have this and only this data model.

I would create two collections: persons and readinglists.

persons would look like:

{
  "id":"123",
  "name": "John Smith",
  "age": 35
}

and readinglists would look like (note that it has a compound natural id):

{
  "_id": { "personid":"123",  "title": "Title1"}, 
  "ISBN": 6246246426724,
  "author": 
           {
              "name": "James Johnson",
              "age": 40
           }
}

Then you can easily update the readinglist:

var query = Query.EQ("_id", new BsonDocument(new BsonElement[]{ new BsonElement("personid":"123"), BsonElement("title":"Title1")}));

readingListCollection.Update(query, Update.Set("author.age": 22));

Answer 4

you can query your main document let's assume your main collection is named "books" this is the structure:

{
    "id":"123",
    "name": "John Smith",
    "age": 35,
    "readingList": 
        [{
            "title": "Title1",
            "ISBN": 6246246426724,
            "author": 
                {
                    "name": "James Johnson",
                    "age": 40
                }
        },
        {
            "title": "Title2",
            "ISBN": 3513531513551,
            "author": 
                {
                    "name": "Sam Hill",
                    "age": 20
                }
        }]
}

// you need a query that returns the main document by id for example, when you have the main document you can query at the one you want to modify in the list and assing it to a varibale let's say readItem, then do the modifications you need and after that you can update only the fields you need using set and onle the element in the array using "$" something like:

readItem.title = "some new title";
readItem.age++;
var update = MongoDB.Driver.Builders.Update.Set("readingList.$", BsonDocumentWrapper.Create(readItem));
Update<Book>(query, update);