JIYIK CN >

This article will discuss how to efficiently update multiple documents in MongoDB.

updateMany()Methods in MongoDB

Using the update method in MongoDB db.collection.updateMany(), you can update multiple documents in a collection. This method changes all the collection documents that match the specified filter.

Here are some considerations when using this method.

grammar:

db.collection.updateMany(
    <filter>,
    <update>,
   {
     upsert: <boolean>,
     writeConcern: <document>,
     collation: <document>,
     arrayFilters: [ <filterdocument1>, <filterdocument2>... ],
     hint: <document|string>
   }
)

parameter:

• filter: This is the first parameter of the method. It specifies the selection criteria for the update.

  This parameter is of type Document. If it contains an empty record, {}then this method will update all documents of the collection with the updated document.

• update: This is the second parameter of the method. This parameter type is either a document or a pipe and it contains the changes to the document.

  It can be an updated document (containing edit operator expressions) or an aggregation pipeline (containing only aggregation steps, such as $addFields, $projectand $replaceRoot).

Optional parameters:

• upsert: The value of this parameter is true or false. The value of this parameter is assumed to be true true.

  This procedure will update all documents that meet the criteria specified in the scheme. If any document in the collection does not fit the provided filter, this method will enter the new document (i.e. the updated document) in the collection.

  The default value for this option is false, which is a boolean value.

• writeConcern: This is the only option when you do not want to use the default write concern. This option has parameter type documentation.

• collation: It describes how the collation will be used in the operation. It also allows the user to establish language-specific string comparison standards, such as lowercase and accent mark rules.

  This option has a parameter type for the documentation.

• arrayFilters: This is an array of filter documents that tells you which array elements you want to change for array field updates. This parameter has an array type.

• hint: It is a document or field indicating the filter will be used for the index that supports it. It can accept either an index specification document or an index name string, and it will return an error if you choose an index that does not exist.

• Return: This method will return a boolean value of true(if writeconcernenabled) or false(if writeconcerndisabled) for the document, matchedCounta value of for the number of matching documents, a value of for the number of modified records, and a value of modifiedCountfor updates to inserted documents ._idupsertedId

$setOperators in MongoDB

You typically use $setthe operator to form update parameters. It replaces the value of a field with a user-given value.

grammar:

{ $set: { <field1>: <value1>, <field2>: <value2>, ...}}

Assume fielddoes not exist. The operator will then $setcreate a new field with the value provided in the record.

If you use dot notation definition field, for example embededDoc.field,, and it does not exist in the database field, $setthe operator creates the embedded document.

Create a collection to update in MongoDB

You can use the following productscollection called .

db={
    "products": [
    {
        "_id": 1,
        "name": "xPhone",
        "price": 799,
        "specs": {
            "ram": 4,
            "screen": 6.5,
            "cpu": 2.66
        },
        "color": [
            "white",
            "black"
        ],
        "storage": [
            64,
            128,
            256
        ]
    },
    {
        "_id": 2,
        "name": "xTablet",
        "price": 899,
        "specs": {
            "ram": 16,
            "screen": 9.5,
            "cpu": 3.66
        },
        "color": [
            "white",
            "black",
            "purple"
        ],
        "storage": [
            128,
            256,
            512
        ]
    },
    {
        "_id": 3,
        "name": "SmartTablet",
        "price": 899,
        "specs": {
            "ram": 12,
            "screen": 9.7,
            "cpu": 3.66
        },
        "color": [
            "blue"
        ],
        "storage": [
            16,
            64,
            128
        ]
    },
    {
        "_id": 4,
        "name": "SmartPad",
        "price": 699,
        "specs": {
            "ram": 8,
            "screen": 9.7,
            "cpu": 1.66
        },
        "color": [
            "white",
            "orange",
            "gold",
            "gray"
        ],
        "storage": [
            128,
            256,
            1024
        ]
    },
    {
        "_id": 5,
        "name": "SmartPhone",
        "price": 599,
        "specs": {
            "ram": 4,
            "screen": 5.7,
            "cpu": 1.66
        },
        "color": [
            "white",
            "orange",
            "gold",
            "gray"
        ],
        "storage": [
            128,
            256
        ]
    }
]
}

updateMany()Update multiple documents in MongoDB using the method

The following example uses updateMany()the method to update a record when the price field value is 899..

db.products.updateMany(
    {  price: 899},
    { $set: {  price: 895 }}
)

The input in this query filteris {price: 899},, which specifies the document to be updated. The change to be applied is {$set: { price: 895}}, which assigns the field value to using setthe operator .price895.

Output:

The field in the result document matchedCountindicates the number of matching records, while modifiedCountthe field stores the number of updated documents.

To verify the modification, use find()the method to select the document whose pricefield value is 895,, as shown below:

db.products.find({
    price: 895
}, {
    name: 1,
    price: 1
})

Output:

The above image shows that pricethe field value has been updated successfully.

updateMany()Update embedded documents in MongoDB using the method

The following query uses find()the method to find documents where pricethe value of the field is greater than 700.

db.products.find({
    price: { $gt: 700}
}, {
    name: 1,
    price: 1,
    spec: 1
})

Output:

updateMany()The method is used in the embedded document of these documents specto update the values ​​of the ram, screen, and cpufields:

db.products.updateMany({
    price: { $gt: 700}
}, {
    $set: {
        "spec.ram": 32,
        "spec.screen": 9.8,
        "spec.cpu": 5.66
    }
})

Output:

The results in the image show that the three documents were successfully updated.

updateMany()Update array elements in MongoDB using method

updateMany()The method is used in the following example to update storagethe first and second elements of the document array, where _idare 1, , 2and 3.

db.products.updateMany({
    _id: {
        $in: [1, 2, 3]
    }
}, {
    $set: {
        "storage.0": 16,
        "storage.1": 32
    }
})

Output:

If you productsquery the collection _idfor documents where 1, , 2and , the first and second components of the array have been modified.3storage

db.products.find(
    { _id: { $in: [1,2,3]}},
    { name: 1, storage: 1}
)

Output:

in conclusion

In this tutorial article, you learned how to use updateMany()the Update function to update all records in a collection that meet a condition, and use $setthe Replace operator to replace the value of a field with a specific value.