Você pode atualizar documentos usando:
O driver da sua linguagem de programação.
A IU do MongoDB Atlas (consulte atualizar um documento com o MongoDB Atlas)
➤ Use o menu suspenso Selecione a linguagem no canto superior direito para definir a linguagem dos exemplos a seguir.
Esta página usa os seguintes métodos mongosh:
Os exemplos usam a coleção inventory . Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:
Esta página usa MongoDB Compass para atualizar documentos.
Os exemplos usam a coleção inventory . Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:
Esta página usa os seguintes métodos do MongoDB C Driver :
Os exemplos usam a coleção inventory . Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:
Esta página usa os seguintes métodos do driver C# do MongoDB:
Os exemplos usam a coleção inventory . Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:
Esta página usa as seguintes funções do driver Go do MongoDB:
Os exemplos usam a coleção inventory . Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:
Esta página usa os seguintes métodos do driver Java Reactive Streams:
com.mongodb.reactivestreams.client.MongoCollection.updateOne
com.mongodb.reactivestreams.client.MongoCollection.updateMany
com.mongodb.reactivestreams.client.MongoCollection.replaceOne
Os exemplos usam a coleção inventory . Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:
Esta página utiliza os seguintes métodos Java Synchronous Driver:
Os exemplos usam a coleção inventory . Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:
Esta página usa os seguintes métodos do driver Kotlin Coroutine :
Os exemplos usam a coleção inventory . Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:
Esta página usa os seguintes métodos do driver Motor:
Os exemplos usam a coleção inventory . Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:
Esta página usa os seguintes métodos do driver do MongoDB Node.js:
Os exemplos usam a coleção inventory . Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:
Esta página usa os seguintes métodos da biblioteca PHP do MongoDB:
Os exemplos usam a coleção inventory . Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:
Esta página usa os seguintes Métodos do driver Python PyMongo :
Os exemplos usam a coleção inventory . Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:
Esta página usa os seguintes métodos do driver do MongoDB Ruby:
Os exemplos usam a coleção inventory . Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:
Esta página usa os seguintes métodos do driver Scala do MongoDB:
Os exemplos usam a coleção inventory . Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:
db.inventory.insertMany( [ { item: "canvas", qty: 100, size: { h: 28, w: 35.5, uom: "cm" }, status: "A" }, { item: "journal", qty: 25, size: { h: 14, w: 21, uom: "cm" }, status: "A" }, { item: "mat", qty: 85, size: { h: 27.9, w: 35.5, uom: "cm" }, status: "A" }, { item: "mousepad", qty: 25, size: { h: 19, w: 22.85, uom: "cm" }, status: "P" }, { item: "notebook", qty: 50, size: { h: 8.5, w: 11, uom: "in" }, status: "P" }, { item: "paper", qty: 100, size: { h: 8.5, w: 11, uom: "in" }, status: "D" }, { item: "planner", qty: 75, size: { h: 22.85, w: 30, uom: "cm" }, status: "D" }, { item: "postcard", qty: 45, size: { h: 10, w: 15.25, uom: "cm" }, status: "A" }, { item: "sketchbook", qty: 80, size: { h: 14, w: 21, uom: "cm" }, status: "A" }, { item: "sketch pad", qty: 95, size: { h: 22.85, w: 30.5, uom: "cm" }, status: "A" } ] );
[ { "item": "canvas", "qty": 100, "size": { "h": 28, "w": 35.5, "uom": "cm" }, "status": "A" }, { "item": "journal", "qty": 25, "size": { "h": 14, "w": 21, "uom": "cm" }, "status": "A" }, { "item": "mat", "qty": 85, "size": { "h": 27.9, "w": 35.5, "uom": "cm" }, "status": "A" }, { "item": "mousepad", "qty": 25, "size": { "h": 19, "w": 22.85, "uom": "cm" }, "status": "P" }, { "item": "notebook", "qty": 50, "size": { "h": 8.5, "w": 11, "uom": "in" }, "status": "P" }, { "item": "paper", "qty": 100, "size": { "h": 8.5, "w": 11, "uom": "in" }, "status": "D" }, { "item": "planner", "qty": 75, "size": { "h": 22.85, "w": 30, "uom": "cm" }, "status": "D" }, { "item": "postcard", "qty": 45, "size": { "h": 10, "w": 15.25, "uom": "cm" }, "status": "A" }, { "item": "sketchbook", "qty": 80, "size": { "h": 14, "w": 21, "uom": "cm" }, "status": "A" }, { "item": "sketch pad", "qty": 95, "size": { "h": 22.85, "w": 30.5, "uom": "cm" }, "status": "A" } ]
Para obter instruções sobre como inserir documentos usando o MongoDB Compass, consulte Inserir documentos.
mongoc_collection_t *collection; mongoc_bulk_operation_t *bulk; bson_t *doc; bool r; bson_error_t error; bson_t reply; collection = mongoc_database_get_collection (db, "inventory"); bulk = mongoc_collection_create_bulk_operation_with_opts (collection, NULL); doc = BCON_NEW ( "item", BCON_UTF8 ("canvas"), "qty", BCON_INT64 (100), "size", "{", "h", BCON_DOUBLE (28), "w", BCON_DOUBLE (35.5), "uom", BCON_UTF8 ("cm"), "}", "status", BCON_UTF8 ("A")); r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error); bson_destroy (doc); if (!r) { MONGOC_ERROR ("%s\n", error.message); goto done; } doc = BCON_NEW ( "item", BCON_UTF8 ("journal"), "qty", BCON_INT64 (25), "size", "{", "h", BCON_DOUBLE (14), "w", BCON_DOUBLE (21), "uom", BCON_UTF8 ("cm"), "}", "status", BCON_UTF8 ("A")); r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error); bson_destroy (doc); if (!r) { MONGOC_ERROR ("%s\n", error.message); goto done; } doc = BCON_NEW ( "item", BCON_UTF8 ("mat"), "qty", BCON_INT64 (85), "size", "{", "h", BCON_DOUBLE (27.9), "w", BCON_DOUBLE (35.5), "uom", BCON_UTF8 ("cm"), "}", "status", BCON_UTF8 ("A")); r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error); bson_destroy (doc); if (!r) { MONGOC_ERROR ("%s\n", error.message); goto done; } doc = BCON_NEW ( "item", BCON_UTF8 ("mousepad"), "qty", BCON_INT64 (25), "size", "{", "h", BCON_DOUBLE (19), "w", BCON_DOUBLE (22.85), "uom", BCON_UTF8 ("cm"), "}", "status", BCON_UTF8 ("P")); r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error); bson_destroy (doc); if (!r) { MONGOC_ERROR ("%s\n", error.message); goto done; } doc = BCON_NEW ( "item", BCON_UTF8 ("notebook"), "qty", BCON_INT64 (50), "size", "{", "h", BCON_DOUBLE (8.5), "w", BCON_DOUBLE (11), "uom", BCON_UTF8 ("in"), "}", "status", BCON_UTF8 ("P")); r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error); bson_destroy (doc); if (!r) { MONGOC_ERROR ("%s\n", error.message); goto done; } doc = BCON_NEW ( "item", BCON_UTF8 ("paper"), "qty", BCON_INT64 (100), "size", "{", "h", BCON_DOUBLE (8.5), "w", BCON_DOUBLE (11), "uom", BCON_UTF8 ("in"), "}", "status", BCON_UTF8 ("D")); r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error); bson_destroy (doc); if (!r) { MONGOC_ERROR ("%s\n", error.message); goto done; } doc = BCON_NEW ( "item", BCON_UTF8 ("planner"), "qty", BCON_INT64 (75), "size", "{", "h", BCON_DOUBLE (22.85), "w", BCON_DOUBLE (30), "uom", BCON_UTF8 ("cm"), "}", "status", BCON_UTF8 ("D")); r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error); bson_destroy (doc); if (!r) { MONGOC_ERROR ("%s\n", error.message); goto done; } doc = BCON_NEW ( "item", BCON_UTF8 ("postcard"), "qty", BCON_INT64 (45), "size", "{", "h", BCON_DOUBLE (10), "w", BCON_DOUBLE (15.25), "uom", BCON_UTF8 ("cm"), "}", "status", BCON_UTF8 ("A")); r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error); bson_destroy (doc); if (!r) { MONGOC_ERROR ("%s\n", error.message); goto done; } doc = BCON_NEW ( "item", BCON_UTF8 ("sketchbook"), "qty", BCON_INT64 (80), "size", "{", "h", BCON_DOUBLE (14), "w", BCON_DOUBLE (21), "uom", BCON_UTF8 ("cm"), "}", "status", BCON_UTF8 ("A")); r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error); bson_destroy (doc); if (!r) { MONGOC_ERROR ("%s\n", error.message); goto done; } doc = BCON_NEW ( "item", BCON_UTF8 ("sketch pad"), "qty", BCON_INT64 (95), "size", "{", "h", BCON_DOUBLE (22.85), "w", BCON_DOUBLE (30.5), "uom", BCON_UTF8 ("cm"), "}", "status", BCON_UTF8 ("A")); r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error); bson_destroy (doc); if (!r) { MONGOC_ERROR ("%s\n", error.message); goto done; } /* "reply" is initialized on success or error */ r = (bool) mongoc_bulk_operation_execute (bulk, &reply, &error); if (!r) { MONGOC_ERROR ("%s\n", error.message); }
var documents = new[] { new BsonDocument { { "item", "canvas" }, { "qty", 100 }, { "size", new BsonDocument { { "h", 28 }, { "w", 35.5 }, { "uom", "cm" } } }, { "status", "A" } }, new BsonDocument { { "item", "journal" }, { "qty", 25 }, { "size", new BsonDocument { { "h", 14 }, { "w", 21 }, { "uom", "cm" } } }, { "status", "A" } }, new BsonDocument { { "item", "mat" }, { "qty", 85 }, { "size", new BsonDocument { { "h", 27.9 }, { "w", 35.5 }, { "uom", "cm" } } }, { "status", "A" } }, new BsonDocument { { "item", "mousepad" }, { "qty", 25 }, { "size", new BsonDocument { { "h", 19 }, { "w", 22.85 }, { "uom", "cm" } } }, { "status", "P" } }, new BsonDocument { { "item", "notebook" }, { "qty", 50 }, { "size", new BsonDocument { { "h", 8.5 }, { "w", 11 }, { "uom", "in" } } }, { "status", "P" } }, new BsonDocument { { "item", "paper" }, { "qty", 100 }, { "size", new BsonDocument { { "h", 8.5 }, { "w", 11 }, { "uom", "in" } } }, { "status", "D" } }, new BsonDocument { { "item", "planner" }, { "qty", 75 }, { "size", new BsonDocument { { "h", 22.85 }, { "w", 30 }, { "uom", "cm" } } }, { "status", "D" } }, new BsonDocument { { "item", "postcard" }, { "qty", 45 }, { "size", new BsonDocument { { "h", 10 }, { "w", 15.25 }, { "uom", "cm" } } }, { "status", "A" } }, new BsonDocument { { "item", "sketchbook" }, { "qty", 80 }, { "size", new BsonDocument { { "h", 14 }, { "w", 21 }, { "uom", "cm" } } }, { "status", "A" } }, new BsonDocument { { "item", "sketch pad" }, { "qty", 95 }, { "size", new BsonDocument { { "h", 22.85 }, { "w", 30.5 }, { "uom", "cm" } } }, { "status", "A" } }, }; collection.InsertMany(documents);
docs := []any{ bson.D{ {"item", "canvas"}, {"qty", 100}, {"size", bson.D{ {"h", 28}, {"w", 35.5}, {"uom", "cm"}, }}, {"status", "A"}, }, bson.D{ {"item", "journal"}, {"qty", 25}, {"size", bson.D{ {"h", 14}, {"w", 21}, {"uom", "cm"}, }}, {"status", "A"}, }, bson.D{ {"item", "mat"}, {"qty", 85}, {"size", bson.D{ {"h", 27.9}, {"w", 35.5}, {"uom", "cm"}, }}, {"status", "A"}, }, bson.D{ {"item", "mousepad"}, {"qty", 25}, {"size", bson.D{ {"h", 19}, {"w", 22.85}, {"uom", "in"}, }}, {"status", "P"}, }, bson.D{ {"item", "notebook"}, {"qty", 50}, {"size", bson.D{ {"h", 8.5}, {"w", 11}, {"uom", "in"}, }}, {"status", "P"}, }, bson.D{ {"item", "paper"}, {"qty", 100}, {"size", bson.D{ {"h", 8.5}, {"w", 11}, {"uom", "in"}, }}, {"status", "D"}, }, bson.D{ {"item", "planner"}, {"qty", 75}, {"size", bson.D{ {"h", 22.85}, {"w", 30}, {"uom", "cm"}, }}, {"status", "D"}, }, bson.D{ {"item", "postcard"}, {"qty", 45}, {"size", bson.D{ {"h", 10}, {"w", 15.25}, {"uom", "cm"}, }}, {"status", "A"}, }, bson.D{ {"item", "sketchbook"}, {"qty", 80}, {"size", bson.D{ {"h", 14}, {"w", 21}, {"uom", "cm"}, }}, {"status", "A"}, }, bson.D{ {"item", "sketch pad"}, {"qty", 95}, {"size", bson.D{ {"h", 22.85}, {"w", 30.5}, {"uom", "cm"}, }}, {"status", "A"}, }, } result, err := coll.InsertMany(context.TODO(), docs)
Publisher<Success> insertManyPublisher = collection.insertMany(asList( Document.parse("{ item: 'canvas', qty: 100, size: { h: 28, w: 35.5, uom: 'cm' }, status: 'A' }"), Document.parse("{ item: 'journal', qty: 25, size: { h: 14, w: 21, uom: 'cm' }, status: 'A' }"), Document.parse("{ item: 'mat', qty: 85, size: { h: 27.9, w: 35.5, uom: 'cm' }, status: 'A' }"), Document.parse("{ item: 'mousepad', qty: 25, size: { h: 19, w: 22.85, uom: 'cm' }, status: 'P' }"), Document.parse("{ item: 'notebook', qty: 50, size: { h: 8.5, w: 11, uom: 'in' }, status: 'P' }"), Document.parse("{ item: 'paper', qty: 100, size: { h: 8.5, w: 11, uom: 'in' }, status: 'D' }"), Document.parse("{ item: 'planner', qty: 75, size: { h: 22.85, w: 30, uom: 'cm' }, status: 'D' }"), Document.parse("{ item: 'postcard', qty: 45, size: { h: 10, w: 15.25, uom: 'cm' }, status: 'A' }"), Document.parse("{ item: 'sketchbook', qty: 80, size: { h: 14, w: 21, uom: 'cm' }, status: 'A' }"), Document.parse("{ item: 'sketch pad', qty: 95, size: { h: 22.85, w: 30.5, uom: 'cm' }, status: 'A' }") ));
collection.insertMany(asList( Document.parse("{ item: 'canvas', qty: 100, size: { h: 28, w: 35.5, uom: 'cm' }, status: 'A' }"), Document.parse("{ item: 'journal', qty: 25, size: { h: 14, w: 21, uom: 'cm' }, status: 'A' }"), Document.parse("{ item: 'mat', qty: 85, size: { h: 27.9, w: 35.5, uom: 'cm' }, status: 'A' }"), Document.parse("{ item: 'mousepad', qty: 25, size: { h: 19, w: 22.85, uom: 'cm' }, status: 'P' }"), Document.parse("{ item: 'notebook', qty: 50, size: { h: 8.5, w: 11, uom: 'in' }, status: 'P' }"), Document.parse("{ item: 'paper', qty: 100, size: { h: 8.5, w: 11, uom: 'in' }, status: 'D' }"), Document.parse("{ item: 'planner', qty: 75, size: { h: 22.85, w: 30, uom: 'cm' }, status: 'D' }"), Document.parse("{ item: 'postcard', qty: 45, size: { h: 10, w: 15.25, uom: 'cm' }, status: 'A' }"), Document.parse("{ item: 'sketchbook', qty: 80, size: { h: 14, w: 21, uom: 'cm' }, status: 'A' }"), Document.parse("{ item: 'sketch pad', qty: 95, size: { h: 22.85, w: 30.5, uom: 'cm' }, status: 'A' }") ));
collection.insertMany( listOf( Document("item", "canvas") .append("qty", 100) .append("size", Document("h", 28).append("w", 35.5).append("uom", "cm")) .append("status", "A"), Document("item", "journal") .append("qty", 25) .append("size", Document("h", 14).append("w", 21).append("uom", "cm")) .append("status", "A"), Document("item", "mat") .append("qty", 85) .append("size", Document("h", 27.9).append("w", 35.5).append("uom", "cm")) .append("status", "A"), Document("item", "mousepad") .append("qty", 25) .append("size", Document("h", 19).append("w", 22.85).append("uom", "cm")) .append("status", "P"), Document("item", "notebook") .append("qty", 50) .append("size", Document("h", 8.5).append("w", 11).append("uom", "in")) .append("status", "P"), Document("item", "paper") .append("qty", 100) .append("size", Document("h", 8.5).append("w", 11).append("uom", "in")) .append("status", "D"), Document("item", "planner") .append("qty", 75) .append("size", Document("h", 22.85).append("w", 30).append("uom", "cm")) .append("status", "D"), Document("item", "postcard") .append("qty", 45) .append("size", Document("h", 10).append("w", 15.25).append("uom", "cm")) .append("status", "A"), Document("item", "sketchbook") .append("qty", 80) .append("size", Document("h", 14).append("w", 21).append("uom", "cm")) .append("status", "A"), Document("item", "sketch pad") .append("qty", 95) .append("size", Document("h", 22.85).append("w", 30.5).append("uom", "cm")) .append("status", "A"), ) )
await db.inventory.insert_many( [ { "item": "canvas", "qty": 100, "size": {"h": 28, "w": 35.5, "uom": "cm"}, "status": "A", }, { "item": "journal", "qty": 25, "size": {"h": 14, "w": 21, "uom": "cm"}, "status": "A", }, { "item": "mat", "qty": 85, "size": {"h": 27.9, "w": 35.5, "uom": "cm"}, "status": "A", }, { "item": "mousepad", "qty": 25, "size": {"h": 19, "w": 22.85, "uom": "cm"}, "status": "P", }, { "item": "notebook", "qty": 50, "size": {"h": 8.5, "w": 11, "uom": "in"}, "status": "P", }, { "item": "paper", "qty": 100, "size": {"h": 8.5, "w": 11, "uom": "in"}, "status": "D", }, { "item": "planner", "qty": 75, "size": {"h": 22.85, "w": 30, "uom": "cm"}, "status": "D", }, { "item": "postcard", "qty": 45, "size": {"h": 10, "w": 15.25, "uom": "cm"}, "status": "A", }, { "item": "sketchbook", "qty": 80, "size": {"h": 14, "w": 21, "uom": "cm"}, "status": "A", }, { "item": "sketch pad", "qty": 95, "size": {"h": 22.85, "w": 30.5, "uom": "cm"}, "status": "A", }, ] )
await db.collection('inventory').insertMany([ { item: 'canvas', qty: 100, size: { h: 28, w: 35.5, uom: 'cm' }, status: 'A' }, { item: 'journal', qty: 25, size: { h: 14, w: 21, uom: 'cm' }, status: 'A' }, { item: 'mat', qty: 85, size: { h: 27.9, w: 35.5, uom: 'cm' }, status: 'A' }, { item: 'mousepad', qty: 25, size: { h: 19, w: 22.85, uom: 'cm' }, status: 'P' }, { item: 'notebook', qty: 50, size: { h: 8.5, w: 11, uom: 'in' }, status: 'P' }, { item: 'paper', qty: 100, size: { h: 8.5, w: 11, uom: 'in' }, status: 'D' }, { item: 'planner', qty: 75, size: { h: 22.85, w: 30, uom: 'cm' }, status: 'D' }, { item: 'postcard', qty: 45, size: { h: 10, w: 15.25, uom: 'cm' }, status: 'A' }, { item: 'sketchbook', qty: 80, size: { h: 14, w: 21, uom: 'cm' }, status: 'A' }, { item: 'sketch pad', qty: 95, size: { h: 22.85, w: 30.5, uom: 'cm' }, status: 'A' } ]);
$insertManyResult = $db->inventory->insertMany([ [ 'item' => 'canvas', 'qty' => 100, 'size' => ['h' => 28, 'w' => 35.5, 'uom' => 'cm'], 'status' => 'A', ], [ 'item' => 'journal', 'qty' => 25, 'size' => ['h' => 14, 'w' => 21, 'uom' => 'cm'], 'status' => 'A', ], [ 'item' => 'mat', 'qty' => 85, 'size' => ['h' => 27.9, 'w' => 35.5, 'uom' => 'cm'], 'status' => 'A', ], [ 'item' => 'mousepad', 'qty' => 25, 'size' => ['h' => 19, 'w' => 22.85, 'uom' => 'cm'], 'status' => 'P', ], [ 'item' => 'notebook', 'qty' => 50, 'size' => ['h' => 8.5, 'w' => 11, 'uom' => 'in'], 'status' => 'P', ], [ 'item' => 'paper', 'qty' => 100, 'size' => ['h' => 8.5, 'w' => 11, 'uom' => 'in'], 'status' => 'D', ], [ 'item' => 'planner', 'qty' => 75, 'size' => ['h' => 22.85, 'w' => 30, 'uom' => 'cm'], 'status' => 'D', ], [ 'item' => 'postcard', 'qty' => 45, 'size' => ['h' => 10, 'w' => 15.25, 'uom' => 'cm'], 'status' => 'A', ], [ 'item' => 'sketchbook', 'qty' => 80, 'size' => ['h' => 14, 'w' => 21, 'uom' => 'cm'], 'status' => 'A', ], [ 'item' => 'sketch pad', 'qty' => 95, 'size' => ['h' => 22.85, 'w' => 30.5, 'uom' => 'cm'], 'status' => 'A', ], ]);
db.inventory.insert_many( [ { "item": "canvas", "qty": 100, "size": {"h": 28, "w": 35.5, "uom": "cm"}, "status": "A", }, { "item": "journal", "qty": 25, "size": {"h": 14, "w": 21, "uom": "cm"}, "status": "A", }, { "item": "mat", "qty": 85, "size": {"h": 27.9, "w": 35.5, "uom": "cm"}, "status": "A", }, { "item": "mousepad", "qty": 25, "size": {"h": 19, "w": 22.85, "uom": "cm"}, "status": "P", }, { "item": "notebook", "qty": 50, "size": {"h": 8.5, "w": 11, "uom": "in"}, "status": "P", }, { "item": "paper", "qty": 100, "size": {"h": 8.5, "w": 11, "uom": "in"}, "status": "D", }, { "item": "planner", "qty": 75, "size": {"h": 22.85, "w": 30, "uom": "cm"}, "status": "D", }, { "item": "postcard", "qty": 45, "size": {"h": 10, "w": 15.25, "uom": "cm"}, "status": "A", }, { "item": "sketchbook", "qty": 80, "size": {"h": 14, "w": 21, "uom": "cm"}, "status": "A", }, { "item": "sketch pad", "qty": 95, "size": {"h": 22.85, "w": 30.5, "uom": "cm"}, "status": "A", }, ] )
client[:inventory].insert_many([ { item: 'canvas', qty: 100, size: { h: 28, w: 35.5, uom: 'cm' }, status: 'A' }, { item: 'journal', qty: 25, size: { h: 14, w: 21, uom: 'cm' }, status: 'A' }, { item: 'mat', qty: 85, size: { h: 27.9, w: 35.5, uom: 'cm' }, status: 'A' }, { item: 'mousepad', qty: 25, size: { h: 19, w: 22.85, uom: 'cm' }, status: 'P' }, { item: 'notebook', qty: 50, size: { h: 8.5, w: 11, uom: 'in' }, status: 'P' }, { item: 'paper', qty: 100, size: { h: 8.5, w: 11, uom: 'in' }, status: 'D' }, { item: 'planner', qty: 75, size: { h: 22.85, w: 30, uom: 'cm' }, status: 'D' }, { item: 'postcard', qty: 45, size: { h: 10, w: 15.25, uom: 'cm' }, status: 'A' }, { item: 'sketchbook', qty: 80, size: { h: 14, w: 21, uom: 'cm' }, status: 'A' }, { item: 'sketch pad', qty: 95, size: { h: 22.85, w: 30.5, uom: 'cm' }, status: 'A' } ])
collection.insertMany(Seq( Document("""{ item: "canvas", qty: 100, size: { h: 28, w: 35.5, uom: "cm" }, status: "A" }"""), Document("""{ item: "journal", qty: 25, size: { h: 14, w: 21, uom: "cm" }, status: "A" }"""), Document("""{ item: "mat", qty: 85, size: { h: 27.9, w: 35.5, uom: "cm" }, status: "A" }"""), Document("""{ item: "mousepad", qty: 25, size: { h: 19, w: 22.85, uom: "cm" }, status: "P" }"""), Document("""{ item: "notebook", qty: 50, size: { h: 8.5, w: 11, uom: "in" }, status: "P" }"""), Document("""{ item: "paper", qty: 100, size: { h: 8.5, w: 11, uom: "in" }, status: "D" }"""), Document("""{ item: "planner", qty: 75, size: { h: 22.85, w: 30, uom: "cm" }, status: "D" }"""), Document("""{ item: "postcard", qty: 45, size: { h: 10, w: 15.25, uom: "cm" }, status: "A" }"""), Document("""{ item: "sketchbook", qty: 80, size: { h: 14, w: 21, uom: "cm" }, status: "A" }"""), Document("""{ item: "sketch pad", qty: 95, size: { h: 22.85, w: 30.5, uom: "cm" }, status: "A" }""") )).execute()
Atualizar documentos em uma coleção
Para modificar valores de campo , use Operadores de Atualização de Campo,$set como.
Passe um documento de atualização para os métodos de atualização:
{ <update operator>: { <field1>: <value1>, ... }, <update operator>: { <field2>: <value2>, ... }, ... }
Alguns operadores de atualização, como $set, criarão o campo se o campo não existir. Consulte a referência individual do operador de atualização para obter detalhes.
Para atualizar um documento no Compass, passe o mouse sobre o documento de destino e clique no ícone de lápis:

Depois de clicar no ícone de lápis, o documento entra no modo de edição:

Agora você pode alterar este documento clicando no item que deseja alterar e modificando o valor.
Para obter instruções detalhadas, consulte documentação do Compass ou siga o exemplo abaixo.
Para modificar valores de campo , use Operadores de Atualização de Campo,$set como.
Passe um documento de atualização para as funções de atualização:
{ <update operator>: { <field1>: <value1>, ... }, <update operator>: { <field2>: <value2>, ... }, ... }
Alguns operadores de atualização, como $set, criarão o campo se o campo não existir. Consulte a referência individual do operador de atualização para obter detalhes.
Para modificar valores de campo , use Operadores de Atualização de Campo,$set como.
Passe um documento de atualização para os métodos de atualização:
{ <update operator> => { <field1> => <value1>, ... }, <update operator> => { <field2> => <value2>, ... }, ... }
Alguns operadores de atualização, como $set, criarão o campo se o campo não existir. Consulte a referência individual do operador de atualização para obter detalhes.
Para modificar valores de campo , use Operadores de Atualização de Campo,$set como.
Alguns operadores de atualização, como $set, criarão o campo se o campo não existir. Consulte a referência individual do operador de atualização para obter detalhes.
Para modificar valores de campo , use Operadores de Atualização de Campo,$set como.
O driver fornece a com.mongodb.client.model.Updates classe para criar documentos de atualização:
combine(set(<field1>, <value1>), set(<field2>, <value2>))
Para obter uma lista dos auxiliares de atualização, consulte com.mongodb.client.model.Updates.
Alguns operadores de atualização, como $set, criarão o campo se o campo não existir. Consulte a referência individual do operador de atualização para obter detalhes.
Para modificar valores de campo , use Operadores de Atualização de Campo,$set como.
O driver fornece a com.mongodb.client.model.Updates classe para criar documentos de atualização:
combine(set(<field1>, <value1>), set(<field2>, <value2>))
Para obter uma lista dos auxiliares de atualização, consulte com.mongodb.client.model.Updates.
Alguns operadores de atualização, como $set, criarão o campo se o campo não existir. Consulte a referência individual do operador de atualização para obter detalhes.
Para modificar valores de campo , use Operadores de Atualização de Campo,$set como.
O driver fornece a classe com.mongodb.client.model.Updates para criar documentos de atualização. O código a seguir mostra um documento para atualizar que usa métodos da classe de construtores Updates:
combine(set(<field1>, <value1>), set(<field2>, <value2>))
Alguns operadores de atualização, como $set, criarão o campo se o campo não existir. Consulte a referência individual do operador de atualização para obter detalhes.
Para modificar valores de campo , use Operadores de Atualização de Campo,$set como.
Passe um documento de atualização para os métodos de atualização:
{ <update operator>: { <field1>: <value1>, ... }, <update operator>: { <field2>: <value2>, ... }, ... }
Alguns operadores de atualização, como $set, criarão o campo se o campo não existir. Consulte a referência individual do operador de atualização para obter detalhes.
Para modificar valores de campo , use Operadores de Atualização de Campo,$set como.
Passe um documento de atualização para os métodos de atualização:
{ <update operator>: { <field1>: <value1>, ... }, <update operator>: { <field2>: <value2>, ... }, ... }
Alguns operadores de atualização, como $set, criarão o campo se o campo não existir. Consulte a referência individual do operador de atualização para obter detalhes.
Para modificar valores de campo , use Operadores de Atualização de Campo,$set como.
Passe um documento de atualização para os métodos de atualização:
[ <update operator> => [ <field1> => <value1>, ... ], <update operator> => [ <field2> => <value2>, ... ], ... ]
Alguns operadores de atualização, como $set, criarão o campo se o campo não existir. Consulte a referência individual do operador de atualização para obter detalhes.
Para modificar valores de campo , use Operadores de Atualização de Campo,$set como.
Passe um documento de atualização para os métodos de atualização:
{ <update operator>: { <field1>: <value1>, ... }, <update operator>: { <field2>: <value2>, ... }, ... }
Alguns operadores de atualização, como $set, criarão o campo se o campo não existir. Consulte a referência individual do operador de atualização para obter detalhes.
Para modificar valores de campo , use Operadores de Atualização de Campo,$set como.
Passe um documento de atualização para os métodos de atualização:
{ <update operator> => { <field1> => <value1>, ... }, <update operator> => { <field2> => <value2>, ... }, ... }
Alguns operadores de atualização, como $set, criarão o campo se o campo não existir. Consulte a referência individual do operador de atualização para obter detalhes.
Para modificar valores de campo , use Operadores de Atualização de Campo,$set como.
Passe um documento de atualização para os métodos de atualização:
( set (<field1>, <value1>), set (<field2>, <value2>), ... )
Alguns operadores de atualização, como $set, criarão o campo se o campo não existir. Consulte a referência individual do operador de atualização para obter detalhes.
Observação
O MongoDB pode aceitar um pipeline de agregação em vez de um documento de atualização. Para obter detalhes, consulte a página de referência do método.
Atualizar um único documento
O exemplo a seguir usa o método db.collection.updateOne() na collection inventory para atualizar o primeiro documento em que item for igual a "paper":
O exemplo a seguir demonstra o uso do MongoDB Compass para modificar um único documento em que item: paper na coleção inventory :
Observação
Este exemplo utiliza a Visualização da Tabela do Compass para modificar o documento. O processo de edição usando a Visualização de lista do Compass segue uma abordagem semelhante.
Para obter mais informações sobre as diferenças entre a Exibição de Tabela e a Exibição de Lista no Compass, consulte a documentação do Compass.
O exemplo a seguir usa a função mongoc_collection_update_one na coleção inventory para atualizar o primeiro documento em que item é igual a "paper":
O exemplo a seguir usa o método IMongoCollection.UpdateOne() na coleção inventory para atualizar o primeiro documento em que item é igual a "paper":
O exemplo a seguir usa o método Collection.UpdateOne na coleção inventory para atualizar o primeiro documento em que item é igual a "paper":
O exemplo a seguir usa o com.mongodb.reactivestreams.client.MongoCollection.updateOne na coleção inventory para atualizar o primeiro documento onde item é igual a "paper":
O exemplo a seguir usa o método com.mongodb.client.MongoCollection.updateOne na coleção inventory para atualizar o primeiro documento em que item é igual a "paper":
O exemplo a seguir usa o método MongoCollection.updateOne() método na collection inventory para atualizar o primeiro documento em que item é igual a "paper":
O exemplo a seguir usa o método update_one na coleção inventory para atualizar o primeiro documento em que item é igual a "paper":
O exemplo a seguir usa o método Collection.updateOne () na coleção inventory para atualizar o primeiro documento em que item é igual a "paper":
O exemplo a seguir usa o método updateOne() na coleção inventory para atualizar o primeiro documento em que item é igual a "paper":
O exemplo a seguir usa o método update_one na coleção inventory para atualizar o primeiro documento em que item é igual a "paper":
O exemplo a seguir usa o método update_one() na coleção inventory para atualizar o primeiro documento em que item é igual a "paper":
O exemplo a seguir usa o método updateOne() na coleção inventory para atualizar o primeiro documento em que item é igual a "paper":
db.inventory.updateOne( { item: "paper" }, { $set: { "size.uom": "cm", status: "P" }, $currentDate: { lastModified: true } } )
A operação de atualização:
usa o operador
$setpara atualizar o valor do camposize.uompara"cm"e o valor do campostatuspara"P",usa o operador
$currentDatepara atualizar o valor do campolastModifiedpara a data atual. Se o campolastModifiednão existir,$currentDatecriará o campo. Consulte$currentDatepara obter detalhes.
Modifique o documento de destino da seguinte forma:
Altere o campo
statusdeDparaP.Altere o campo
size.uomdeinparacm.Adicione um novo campo chamado
lastModifiedcujo valor será a data de hoje.
Clique no botão Table na navegação superior para acessar a Visualização de Tabela:
![Visualização da tabela de acesso]()
Use a barra de query do Compass para localizar o documento de destino.
Copie o seguinte documento de filtro na barra de consulta e clique em Find:
{ item: "paper" } ![Localizar documento em papel]()
Passe o mouse sobre o campo
statuse clique no ícone de lápis que aparece no lado direito do documento para entrar novamente no modo de edição.![Clique no botão de edição]()
Altere o valor do campo para
"P".Clique no botão Update abaixo do campo para salvar suas alterações.
Passe o mouse sobre o campo
sizee clique nas setas apontando para fora que aparecem no lado direito do campo. Isso abre uma nova aba que exibe os campos dentro do objetosize:![Expandir objeto de tamanho]()
Usando o mesmo processo descrito nas etapas 3-5 para editar o campo
status, altere o valor do camposize.uompara"cm".Clique na guia mais à esquerda acima da tabela rotulada
inventorypara retornar à exibição de tabela original, que exibe o documento de nível superior:![Clique na aba inventário]()
Passe o mouse sobre o campo
statuse clique no ícone de lápis que aparece no lado direito do documento para entrar novamente no modo de edição.Clique dentro do campo
statuse clique no ícone plus button que aparece no menu de edição.Clique no botão Add Field After status que aparece abaixo do botão de adição:
![Adicionar campo após o status]()
Adicione um novo campo chamado
lastModifiedcom o valor da data de hoje. Defina o tipo de campo comoDate:![Enviar atualização]()
Clique no botão Update abaixo do campo para salvar suas alterações.
Observação
Como o MongoDB Compass não oferece suporte a
$currentDateou qualquer outro operador de atualização de campo, você deve inserir manualmente o valor de data no Compass.
mongoc_collection_t *collection; bson_t *selector; bson_t *update; bool r; bson_error_t error; collection = mongoc_database_get_collection (db, "inventory"); selector = BCON_NEW ("item", BCON_UTF8 ("paper")); update = BCON_NEW ( "$set", "{", "size.uom", BCON_UTF8 ("cm"), "status", BCON_UTF8 ("P"), "}", "$currentDate", "{", "lastModified", BCON_BOOL (true), "}"); r = mongoc_collection_update_one(collection, selector, update, NULL, NULL, &error); bson_destroy (selector); bson_destroy (update); if (!r) { MONGOC_ERROR ("%s\n", error.message); goto done; }
var filter = Builders<BsonDocument>.Filter.Eq("item", "paper"); var update = Builders<BsonDocument>.Update.Set("size.uom", "cm").Set("status", "P").CurrentDate("lastModified"); var result = collection.UpdateOne(filter, update);
A operação de atualização:
usa o operador
$setpara atualizar o valor do camposize.uompara"cm"e o valor do campostatuspara"P",usa o operador
$currentDatepara atualizar o valor do campolastModifiedpara a data atual. Se o campolastModifiednão existir,$currentDatecriará o campo. Consulte$currentDatepara obter detalhes.
result, err := coll.UpdateOne( context.TODO(), bson.D{ {"item", "paper"}, }, bson.D{ {"$set", bson.D{ {"size.uom", "cm"}, {"status", "P"}, }}, {"$currentDate", bson.D{ {"lastModified", true}, }}, }, )
A operação de atualização:
usa o operador
$setpara atualizar o valor do camposize.uompara"cm"e o valor do campostatuspara"P",usa o operador
$currentDatepara atualizar o valor do campolastModifiedpara a data atual. Se o campolastModifiednão existir,$currentDatecriará o campo. Consulte$currentDatepara obter detalhes.
Publisher<UpdateResult> updateOnePublisher = collection.updateOne(eq("item", "paper"), combine(set("size.uom", "cm"), set("status", "P"), currentDate("lastModified")));
A operação de atualização:
usa o operador
$setpara atualizar o valor do camposize.uompara"cm"e o valor do campostatuspara"P",usa o operador
$currentDatepara atualizar o valor do campolastModifiedpara a data atual. Se o campolastModifiednão existir,$currentDatecriará o campo. Consulte$currentDatepara obter detalhes.
collection.updateOne(eq("item", "paper"), combine(set("size.uom", "cm"), set("status", "P"), currentDate("lastModified")));
A operação de atualização:
usa o operador
$setpara atualizar o valor do camposize.uompara"cm"e o valor do campostatuspara"P",usa o operador
$currentDatepara atualizar o valor do campolastModifiedpara a data atual. Se o campolastModifiednão existir,$currentDatecriará o campo. Consulte$currentDatepara obter detalhes.
collection.updateOne(eq("item", "paper"), combine(set("size.uom", "cm"), set("status", "P"), currentDate("lastModified")));
A operação de atualização:
usa o operador
$setpara atualizar o valor do camposize.uompara"cm"e o valor do campostatuspara"P",usa o operador
$currentDatepara atualizar o valor do campolastModifiedpara a data atual. Se o campolastModifiednão existir,$currentDatecriará o campo. Consulte$currentDatepara obter detalhes.
await db.inventory.update_one( {"item": "paper"}, {"$set": {"size.uom": "cm", "status": "P"}, "$currentDate": {"lastModified": True}}, )
A operação de atualização:
usa o operador
$setpara atualizar o valor do camposize.uompara"cm"e o valor do campostatuspara"P",usa o operador
$currentDatepara atualizar o valor do campolastModifiedpara a data atual. Se o campolastModifiednão existir,$currentDatecriará o campo. Consulte$currentDatepara obter detalhes.
await db.collection('inventory').updateOne( { item: 'paper' }, { $set: { 'size.uom': 'cm', status: 'P' }, $currentDate: { lastModified: true } } );
A operação de atualização:
usa o operador
$setpara atualizar o valor do camposize.uompara"cm"e o valor do campostatuspara"P",usa o operador
$currentDatepara atualizar o valor do campolastModifiedpara a data atual. Se o campolastModifiednão existir,$currentDatecriará o campo. Consulte$currentDatepara obter detalhes.
$updateResult = $db->inventory->updateOne( ['item' => 'paper'], [ '$set' => ['size.uom' => 'cm', 'status' => 'P'], '$currentDate' => ['lastModified' => true], ], );
A operação de atualização:
usa o operador
$setpara atualizar o valor do camposize.uompara"cm"e o valor do campostatuspara"P",usa o operador
$currentDatepara atualizar o valor do campolastModifiedpara a data atual. Se o campolastModifiednão existir,$currentDatecriará o campo. Consulte$currentDatepara obter detalhes.
db.inventory.update_one( {"item": "paper"}, {"$set": {"size.uom": "cm", "status": "P"}, "$currentDate": {"lastModified": True}}, )
client[:inventory].update_one({ item: 'paper'}, { '$set' => { 'size.uom' => 'cm', 'status' => 'P' }, '$currentDate' => { 'lastModified' => true } })
A operação de atualização:
usa o operador
$setpara atualizar o valor do camposize.uompara"cm"e o valor do campostatuspara"P",usa o operador
$currentDatepara atualizar o valor do campolastModifiedpara a data atual. Se o campolastModifiednão existir,$currentDatecriará o campo. Consulte$currentDatepara obter detalhes.
collection.updateOne(equal("item", "paper"), combine(set("size.uom", "cm"), set("status", "P"), currentDate("lastModified")) ).execute()
A operação de atualização:
usa o operador
$setpara atualizar o valor do camposize.uompara"cm"e o valor do campostatuspara"P",usa o operador
$currentDatepara atualizar o valor do campolastModifiedpara a data atual. Se o campolastModifiednão existir,$currentDatecriará o campo. Consulte$currentDatepara obter detalhes.
Atualizar vários documentos
O exemplo a seguir usa o método db.collection.updateMany() na collection inventory para atualizar todos os documentos em que qty é menor que 50:
Você pode atualizar somente um documento de cada vez no MongoDB Compass.
O exemplo a seguir usa a função mongoc_collection_update_many na coleção inventory para atualizar todos os documentos em que qty é menor que 50:
O exemplo a seguir usa o método IMongoCollection.UpdateMany() na coleção inventory para atualizar todos os documentos onde qty é menor que 50:
O exemplo a seguir usa o método Collection.UpdateMany na coleção inventory para atualizar todos os documentos onde qty é menor que 50:
O exemplo a seguir usa o método com.mongodb.reactivestreams.client.MongoCollection.updateMany na coleção inventory para atualizar todos os documento em que qty é menor que 50:
O exemplo a seguir usa o método com.mongodb.client.MongoCollection.updateMany na coleção inventory para atualizar todos os documentos em que qty é menor que 50:
O exemplo a seguir usa o método MongoCollection.updateMany() na collection inventory para atualizar todos os documentos onde qty é menor que 50:
O exemplo a seguir usa o método update_many na coleção inventory para atualizar todos os documentos onde qty é menor que 50:
O exemplo a seguir usa o método Collection.updateMany() na coleção inventory para atualizar todos os documentos onde qty é menor que 50:
O exemplo a seguir usa o método updateMany() na coleção inventory para atualizar todos os documentos onde qty é menor que 50:
O exemplo a seguir usa o método update_many na coleção inventory para atualizar todos os documentos onde qty é menor que 50:
O exemplo a seguir usa o método update_many() na coleção inventory para atualizar todos os documentos onde qty é menor que 50:
O exemplo a seguir usa o método updateMany () na inventory coleção para atualizar todos os documentos em que qty é menor 50 que:
db.inventory.updateMany( { "qty": { $lt: 50 } }, { $set: { "size.uom": "in", status: "P" }, $currentDate: { lastModified: true } } )
A operação de atualização:
usa o operador
$setpara atualizar o valor do camposize.uompara"in"e o valor do campostatuspara"P",usa o operador
$currentDatepara atualizar o valor do campolastModifiedpara a data atual. Se o campolastModifiednão existir,$currentDatecriará o campo. Consulte$currentDatepara obter detalhes.
Para atualizar vários documentos, conecte-se à implantação do MongoDB por mongosh ou um driver do MongoDB e siga os exemplos nesta seção para usar o método de sua preferência.
mongoc_collection_t *collection; bson_t *selector; bson_t *update; bool r; bson_error_t error; collection = mongoc_database_get_collection (db, "inventory"); selector = BCON_NEW ( "qty", "{", "$lt", BCON_INT64 (50), "}"); update = BCON_NEW ( "$set", "{", "size.uom", BCON_UTF8 ("in"), "status", BCON_UTF8 ("P"), "}", "$currentDate", "{", "lastModified", BCON_BOOL (true), "}"); r = mongoc_collection_update_many(collection, selector, update, NULL, NULL, &error); bson_destroy (selector); bson_destroy (update); if (!r) { MONGOC_ERROR ("%s\n", error.message); goto done; }
var filter = Builders<BsonDocument>.Filter.Lt("qty", 50); var update = Builders<BsonDocument>.Update.Set("size.uom", "in").Set("status", "P").CurrentDate("lastModified"); var result = collection.UpdateMany(filter, update);
A operação de atualização:
usa o operador
$setpara atualizar o valor do camposize.uompara"in"e o valor do campostatuspara"P",usa o operador
$currentDatepara atualizar o valor do campolastModifiedpara a data atual. Se o campolastModifiednão existir,$currentDatecriará o campo. Consulte$currentDatepara obter detalhes.
result, err := coll.UpdateMany( context.TODO(), bson.D{ {"qty", bson.D{ {"$lt", 50}, }}, }, bson.D{ {"$set", bson.D{ {"size.uom", "cm"}, {"status", "P"}, }}, {"$currentDate", bson.D{ {"lastModified", true}, }}, }, )
A operação de atualização:
usa o operador
$setpara atualizar o valor do camposize.uompara"in"e o valor do campostatuspara"P",usa o operador
$currentDatepara atualizar o valor do campolastModifiedpara a data atual. Se o campolastModifiednão existir,$currentDatecriará o campo. Consulte$currentDatepara obter detalhes.
Publisher<UpdateResult> updateManyPublisher = collection.updateMany(lt("qty", 50), combine(set("size.uom", "in"), set("status", "P"), currentDate("lastModified")));
A operação de atualização:
usa o operador
$setpara atualizar o valor do camposize.uompara"in"e o valor do campostatuspara"P",usa o operador
$currentDatepara atualizar o valor do campolastModifiedpara a data atual. Se o campolastModifiednão existir,$currentDatecriará o campo. Consulte$currentDatepara obter detalhes.
collection.updateMany(lt("qty", 50), combine(set("size.uom", "in"), set("status", "P"), currentDate("lastModified")));
A operação de atualização:
usa o operador
$setpara atualizar o valor do camposize.uompara"in"e o valor do campostatuspara"P",usa o operador
$currentDatepara atualizar o valor do campolastModifiedpara a data atual. Se o campolastModifiednão existir,$currentDatecriará o campo. Consulte$currentDatepara obter detalhes.
collection.updateOne(eq("item", "paper"), combine(set("size.uom", "cm"), set("status", "P"), currentDate("lastModified")));
A operação de atualização:
usa o operador
$setpara atualizar o valor do camposize.uompara"in"e o valor do campostatuspara"P",usa o operador
$currentDatepara atualizar o valor do campolastModifiedpara a data atual. Se o campolastModifiednão existir,$currentDatecriará o campo. Consulte$currentDatepara obter detalhes.
await db.inventory.update_many( {"qty": {"$lt": 50}}, {"$set": {"size.uom": "in", "status": "P"}, "$currentDate": {"lastModified": True}}, )
A operação de atualização:
usa o operador
$setpara atualizar o valor do camposize.uompara"in"e o valor do campostatuspara"P",usa o operador
$currentDatepara atualizar o valor do campolastModifiedpara a data atual. Se o campolastModifiednão existir,$currentDatecriará o campo. Consulte$currentDatepara obter detalhes.
await db.collection('inventory').updateMany( { qty: { $lt: 50 } }, { $set: { 'size.uom': 'in', status: 'P' }, $currentDate: { lastModified: true } } );
A operação de atualização:
usa o operador
$setpara atualizar o valor do camposize.uompara"in"e o valor do campostatuspara"P",usa o operador
$currentDatepara atualizar o valor do campolastModifiedpara a data atual. Se o campolastModifiednão existir,$currentDatecriará o campo. Consulte$currentDatepara obter detalhes.
$updateResult = $db->inventory->updateMany( ['qty' => ['$lt' => 50]], [ '$set' => ['size.uom' => 'cm', 'status' => 'P'], '$currentDate' => ['lastModified' => true], ], );
A operação de atualização:
usa o operador
$setpara atualizar o valor do camposize.uompara"in"e o valor do campostatuspara"P",usa o operador
$currentDatepara atualizar o valor do campolastModifiedpara a data atual. Se o campolastModifiednão existir,$currentDatecriará o campo. Consulte$currentDatepara obter detalhes.
db.inventory.update_many( {"qty": {"$lt": 50}}, {"$set": {"size.uom": "in", "status": "P"}, "$currentDate": {"lastModified": True}}, )
client[:inventory].update_many({ qty: { '$lt' => 50 } }, { '$set' => { 'size.uom' => 'in', 'status' => 'P' }, '$currentDate' => { 'lastModified' => true } })
A operação de atualização:
usa o operador
$setpara atualizar o valor do camposize.uompara"in"e o valor do campostatuspara"P",usa o operador
$currentDatepara atualizar o valor do campolastModifiedpara a data atual. Se o campolastModifiednão existir,$currentDatecriará o campo. Consulte$currentDatepara obter detalhes.
collection.updateMany(lt("qty", 50), combine(set("size.uom", "in"), set("status", "P"), currentDate("lastModified")) ).execute()
A operação de atualização:
usa o operador
$setpara atualizar o valor do camposize.uompara"in"e o valor do campostatuspara"P",usa o operador
$currentDatepara atualizar o valor do campolastModifiedpara a data atual. Se o campolastModifiednão existir,$currentDatecriará o campo. Consulte$currentDatepara obter detalhes.
Substituir um documento
Para substituir todo o conteúdo de um documento, exceto o campo _id, passe um documento totalmente novo como segundo argumento para db.collection.replaceOne().
Ao substituir um documento, o documento substituto deve consistir apenas em pares campo/valor. O documento de substituição não pode incluir expressões de operadores de atualização.
O documento de substituição pode ter campos diferentes do documento original. No documento de substituição, você pode omitir o campo _id, pois o campo _id é imutável. No entanto, se você incluir o campo _id, ele deverá ter o mesmo valor que o valor atual.
O exemplo a seguir substitui o primeiro documento da collection inventory, em que item: "paper":
Você não pode substituir um documento no MongoDB Compass.
Para substituir todo o conteúdo de um documento, exceto o campo _id, passe um documento totalmente novo como o terceiro argumento para mongoc_collection_replace_one.
Ao substituir um documento, o documento substituto deve consistir apenas em pares campo/valor. O documento de substituição não pode incluir expressões de operadores de atualização.
O documento de substituição pode ter campos diferentes do documento original. No documento de substituição, você pode omitir o campo _id, pois o campo _id é imutável. No entanto, se você incluir o campo _id, ele deverá ter o mesmo valor que o valor atual.
O exemplo a seguir substitui o primeiro documento da collection inventory, em que item: "paper":
Para substituir todo o conteúdo de um documento, exceto o campo _id, passe um documento totalmente novo como o segundo argumento para IMongoCollection.ReplaceOne().
Ao substituir um documento, o documento substituto deve consistir apenas em pares campo/valor. O documento de substituição não pode incluir expressões de operadores de atualização.
O documento de substituição pode ter campos diferentes do documento original. No documento de substituição, você pode omitir o campo _id, pois o campo _id é imutável. No entanto, se você incluir o campo _id, ele deverá ter o mesmo valor que o valor atual.
O exemplo a seguir substitui o primeiro documento da collection inventory, em que item: "paper":
Para substituir todo o conteúdo de um documento, exceto o campo _id, passe um documento totalmente novo como o segundo argumento para Collection.ReplaceOne.
Ao substituir um documento, o documento substituto deve consistir apenas em pares campo/valor. O documento de substituição não pode incluir expressões de operadores de atualização.
O documento de substituição pode ter campos diferentes do documento original. No documento de substituição, você pode omitir o campo _id, pois o campo _id é imutável. No entanto, se você incluir o campo _id, ele deverá ter o mesmo valor que o valor atual.
O exemplo a seguir substitui o primeiro documento da collection inventory, em que item: "paper":
Para substituir todo o conteúdo de um documento, exceto o campo _id, passe um documento totalmente novo como o segundo argumento para com.mongodb.reactivestreams.client.MongoCollection.replaceOne.
Ao substituir um documento, o documento substituto deve consistir apenas em pares campo/valor. O documento de substituição não pode incluir expressões de operadores de atualização.
O documento de substituição pode ter campos diferentes do documento original. No documento de substituição, você pode omitir o campo _id, pois o campo _id é imutável. No entanto, se você incluir o campo _id, ele deverá ter o mesmo valor que o valor atual.
O exemplo a seguir substitui o primeiro documento da collection inventory, em que item: "paper":
Para substituir todo o conteúdo de um documento, exceto o campo _id, passe um documento totalmente novo como o segundo argumento para com.mongodb.client.MongoCollection.replaceOne.
Ao substituir um documento, o documento substituto deve consistir apenas em pares campo/valor. O documento de substituição não pode incluir expressões de operadores de atualização.
O documento de substituição pode ter campos diferentes do documento original. No documento de substituição, você pode omitir o campo _id, pois o campo _id é imutável. No entanto, se você incluir o campo _id, ele deverá ter o mesmo valor que o valor atual.
O exemplo a seguir substitui o primeiro documento da collection inventory, em que item: "paper":
Para substituir todo o conteúdo de um documento, exceto o campo _id, passe um documento totalmente novo como o segundo argumento para o MongoCollection.replaceOne() método.
Ao substituir um documento, o documento substituto deve consistir apenas em pares campo/valor. O documento de substituição não pode incluir expressões de operadores de atualização.
O documento de substituição pode ter campos diferentes do documento original. No documento de substituição, você pode omitir o campo _id, pois o campo _id é imutável. No entanto, se você incluir o campo _id, ele deverá ter o mesmo valor que o valor atual.
O exemplo a seguir substitui o primeiro documento da collection inventory, em que item: "paper":
Para substituir todo o conteúdo de um documento, exceto o campo _id, passe um documento totalmente novo como segundo argumento para replace_one.
Ao substituir um documento, o documento substituto deve consistir apenas em pares campo/valor. O documento de substituição não pode incluir expressões de operadores de atualização.
O documento de substituição pode ter campos diferentes do documento original. No documento de substituição, você pode omitir o campo _id, pois o campo _id é imutável. No entanto, se você incluir o campo _id, ele deverá ter o mesmo valor que o valor atual.
O exemplo a seguir substitui o primeiro documento da collection inventory, em que item: "paper":
Para substituir todo o conteúdo de um documento, exceto o campo _id, passe um documento totalmente novo como o segundo argumento para Collection.replaceOne().
Ao substituir um documento, o documento substituto deve consistir apenas em pares campo/valor. O documento de substituição não pode incluir expressões de operadores de atualização.
O documento de substituição pode ter campos diferentes do documento original. No documento de substituição, você pode omitir o campo _id, pois o campo _id é imutável. No entanto, se você incluir o campo _id, ele deverá ter o mesmo valor que o valor atual.
O exemplo a seguir substitui o primeiro documento da collection inventory, em que item: "paper":
Para substituir todo o conteúdo de um documento, exceto o campo _id, passe um documento totalmente novo como o segundo argumento para replaceOne().
Ao substituir um documento, o documento substituto deve consistir apenas em pares campo/valor. O documento de substituição não pode incluir expressões de operadores de atualização.
O documento de substituição pode ter campos diferentes do documento original. No documento de substituição, você pode omitir o campo _id, pois o campo _id é imutável. No entanto, se você incluir o campo _id, ele deverá ter o mesmo valor que o valor atual.
O exemplo a seguir substitui o primeiro documento da collection inventory, em que item: "paper":
Para substituir todo o conteúdo de um documento, exceto o campo _id, passe um documento totalmente novo como segundo argumento para replace_one.
Ao substituir um documento, o documento substituto deve consistir apenas em pares campo/valor. O documento de substituição não pode incluir expressões de operadores de atualização.
O documento de substituição pode ter campos diferentes do documento original. No documento de substituição, você pode omitir o campo _id, pois o campo _id é imutável. No entanto, se você incluir o campo _id, ele deverá ter o mesmo valor que o valor atual.
O exemplo a seguir substitui o primeiro documento da collection inventory, em que item: "paper":
Para substituir todo o conteúdo de um documento, exceto o campo _id, passe um documento totalmente novo como o segundo argumento para replace_one().
Ao substituir um documento, o documento substituto deve consistir apenas em pares campo/valor. O documento de substituição não pode incluir expressões de operadores de atualização.
O documento de substituição pode ter campos diferentes do documento original. No documento de substituição, você pode omitir o campo _id, pois o campo _id é imutável. No entanto, se você incluir o campo _id, ele deverá ter o mesmo valor que o valor atual.
O exemplo a seguir substitui o primeiro documento da collection inventory, em que item: "paper":
Para substituir todo o conteúdo de um documento, exceto o campo _id, passe um documento totalmente novo como o segundo argumento para replaceOne()
Ao substituir um documento, o documento substituto deve consistir apenas em pares campo/valor. O documento de substituição não pode incluir expressões de operadores de atualização.
O documento de substituição pode ter campos diferentes do documento original. No documento de substituição, você pode omitir o campo _id, pois o campo _id é imutável. No entanto, se você incluir o campo _id, ele deverá ter o mesmo valor que o valor atual.
O exemplo a seguir substitui o primeiro documento da collection inventory, em que item: "paper":
db.inventory.replaceOne( { item: "paper" }, { item: "paper", instock: [ { warehouse: "A", qty: 60 }, { warehouse: "B", qty: 40 } ] } )
Para substituir um documento, conecte-se à implantação do MongoDB por mongosh ou um driver do MongoDB e siga os exemplos nesta seção para usar o método de sua preferência.
mongoc_collection_t *collection; bson_t *selector; bson_t *replacement; bool r; bson_error_t error; collection = mongoc_database_get_collection (db, "inventory"); selector = BCON_NEW ("item", BCON_UTF8 ("paper")); replacement = BCON_NEW ( "item", BCON_UTF8 ("paper"), "instock", "[", "{", "warehouse", BCON_UTF8 ("A"), "qty", BCON_INT64 (60), "}","{", "warehouse", BCON_UTF8 ("B"), "qty", BCON_INT64 (40), "}", "]"); /* MONGOC_UPDATE_NONE means "no special options" */ r = mongoc_collection_replace_one(collection, selector, replacement, NULL, NULL, &error); bson_destroy (selector); bson_destroy (replacement); if (!r) { MONGOC_ERROR ("%s\n", error.message); goto done; }
Limpe quaisquer recursos abertos ligando para os seguintes métodos, conforme apropriado:
var filter = Builders<BsonDocument>.Filter.Eq("item", "paper"); var replacement = new BsonDocument { { "item", "paper" }, { "instock", new BsonArray { new BsonDocument { { "warehouse", "A" }, { "qty", 60 } }, new BsonDocument { { "warehouse", "B" }, { "qty", 40 } } } } }; var result = collection.ReplaceOne(filter, replacement);
result, err := coll.ReplaceOne( context.TODO(), bson.D{ {"item", "paper"}, }, bson.D{ {"item", "paper"}, {"instock", bson.A{ bson.D{ {"warehouse", "A"}, {"qty", 60}, }, bson.D{ {"warehouse", "B"}, {"qty", 40}, }, }}, }, )
Publisher<UpdateResult> replaceOnePublisher = collection.replaceOne(eq("item", "paper"), Document.parse("{ item: 'paper', instock: [ { warehouse: 'A', qty: 60 }, { warehouse: 'B', qty: 40 } ] }"));
collection.replaceOne(eq("item", "paper"), Document.parse("{ item: 'paper', instock: [ { warehouse: 'A', qty: 60 }, { warehouse: 'B', qty: 40 } ] }"));
collection.replaceOne(eq("item", "paper"), Document.parse("{ item: 'paper', instock: [ { warehouse: 'A', qty: 60 }, { warehouse: 'B', qty: 40 } ] }"));
await db.inventory.replace_one( {"item": "paper"}, { "item": "paper", "instock": [{"warehouse": "A", "qty": 60}, {"warehouse": "B", "qty": 40}], }, )
await db.collection('inventory').replaceOne( { item: 'paper' }, { item: 'paper', instock: [ { warehouse: 'A', qty: 60 }, { warehouse: 'B', qty: 40 } ] } );
$updateResult = $db->inventory->replaceOne( ['item' => 'paper'], [ 'item' => 'paper', 'instock' => [ ['warehouse' => 'A', 'qty' => 60], ['warehouse' => 'B', 'qty' => 40], ], ], );
db.inventory.replace_one( {"item": "paper"}, { "item": "paper", "instock": [{"warehouse": "A", "qty": 60}, {"warehouse": "B", "qty": 40}], }, )
client[:inventory].replace_one({ item: 'paper' }, { item: 'paper', instock: [ { warehouse: 'A', qty: 60 }, { warehouse: 'B', qty: 40 } ] })
collection.replaceOne(equal("item", "paper"), Document("""{ item: "paper", instock: [ { warehouse: "A", qty: 60 }, { warehouse: "B", qty: 40 } ] }""") ).execute()
Atualizar um documento com MongoDB Atlas
Observação
A IU do MongoDB Atlas atualiza um documento por vez. Para atualizar vários documentos ou substituir um documento inteiro, conecte-se à sua implantação do Atlas a partir de mongosh ou de um driver do MongoDB e siga o exemplo para o método de sua preferência.
Este exemplo usa o conjunto de dados de suprimentos de amostra. Para carregar o conjunto de dados de amostra, consulte Carregar dados de amostra.
Para atualizar um documento no MongoDB Atlas, siga estas etapas:
Na interface do usuário do MongoDB Atlas , vá para a Clusters página do seu projeto.
Se ainda não tiver sido exibido, selecione a organização que contém seu projeto no menu Organizations na barra de navegação.
Se ainda não estiver exibido, selecione seu projeto no menu Projects na barra de navegação.
Na barra lateral, clique em Clusters sob o título Database.
A página Clusters é exibida.
Especifique um filtro de queries.
Você pode especificar um documento de filtro de query no campo Filter. Um documento de filtro de query usa operadores de query para especificar as condições de pesquisa.
Copie o seguinte documento de filtro de query na barra de pesquisa do Filter e clique em Apply:
{ saleDate: { $gte: { $date: "2016-01-01T00:00-00:00" }, $lte: { $date: "2016-01-02T00:00-00:00" } } }
Esse filtro de query retorna todos os documentos na coleção sample_supplies.sales em que saleDate é em ou entre 1 e 2 de janeiro de 2016, horário UTC.
Edit a document.
Para editar um documento exibido nos resultados da query, passe o mouse sobre o documento e clique no ícone de lápis. No editor de documentos, você pode:
Adicionar um novo campo.
Excluir um campo existente.
Editar o nome, valor ou tipo de um campo.
Reverter uma alteração específica.
Para obter instruções detalhadas, consulte Criar, exibir, atualizar e excluir documentos.
Comportamento
Atomicidade
Todas as operações de gravação são atômicas no nível do documento. Para mais informações, veja Atomicidade e Transações.
_id Campo
Depois de definido, você não pode atualizar o valor do campo _id nem substituir um documento por um que tenha um valor _id diferente.
Operações idempotentes
Use updateMany() apenas para operações idempotentes.
Ordem do campo
Para operações de gravação, o MongoDB preserva a ordem dos campos do documento,exceto para os seguintes casos:
O campo
_idé sempre o primeiro campo do documento.As atualizações que incluem
renamingdos nomes de campos podem resultar na reordenação de campos no documento.
Opção Upsert
Se updateOne(), updateMany() ou replaceOne() incluir upsert : true e nenhum documento corresponder ao filtro especificado, a operação criará um novo documento e o inserirá. Se houver documentos correspondentes, a operação modificará ou substituirá os documentos correspondentes.
Para obter detalhes sobre o novo documento criado, consulte as páginas de referência individuais para os métodos.
A opção upsert não está disponível no MongoDB Compass.
Se mongoc_collection_update_one, mongoc_collection_update_many, ou mongoc_collection_replace_one incluir upsert : true e nenhum documento corresponder ao filtro especificado, a operação criará um novo documento e o inserirá. Se houver documentos correspondentes, a operação modificará ou substituirá os documentos correspondentes.
Para obter detalhes sobre o novo documento criado, consulte as páginas de referência individuais para as funções.
Se updateOne(), updateMany() ou replaceOne() incluir uma instância de argumento UpdateOptions com a opção IsUpsert definida como true e nenhum documento corresponder ao filtro especificado, a operação criará um novo documento e o inserirá. Se houver documentos correspondentes, a operação modificará ou substituirá os documentos correspondentes.
Para obter detalhes sobre o novo documento criado, consulte as páginas de referência individuais para os métodos.
Se Collection.UpdateOne incluir a opção Upsert definida como true e nenhum documento corresponder ao filtro especificado, a operação criará um novo documento e o inserirá. Se houver documentos correspondentes, a operação modificará ou substituirá os documentos correspondentes.
Para obter detalhes sobre o novo documento criado, consulte as páginas de referência individuais para os métodos.
Se os métodos update e replace incluírem o parâmetro UpdateOptions que especifica UpdateOptions.upsert(true) e nenhum documento corresponder ao filtro especificado, a operação criará um novo documento e o inserirá. Se houver documentos correspondentes, a operação modificará ou substituirá os documentos correspondentes.
Para obter detalhes sobre o novo documento criado, consulte as páginas de referência individuais para os métodos.
Se os métodos de atualização e substituição incluírem o parâmetro com.mongodb.client.model.updateOptions que especifica com.mongodb.client.model.updateOptions.upsert (true) e nenhum documento corresponder ao filtro especificado, a operação criará um novo documento e o inserirá. Se houver documentos correspondentes, a operação modificará ou substituirá os documentos correspondentes.
Para obter detalhes sobre o novo documento criado, consulte as páginas de referência individuais para os métodos.
Se os métodos de atualização e substituição incluírem o com.mongodb. parâmetro .model.UpdateOptions do cliente upsert(true) que especifica, e nenhum documento corresponde ao filtro especificado, a operação cria um novo documento e o insere. Se houver documentos correspondentes, a operação modificará ou substituirá os documento correspondentes.
Para obter detalhes sobre o novo documento criado, consulte as páginas de referência individuais para os métodos.
Se update_one, update_many ou replace_one incluir upsert : true e nenhum documento corresponder ao filtro especificado, a operação criará um novo documento e o inserirá. Se houver documentos correspondentes, a operação modificará ou substituirá os documentos correspondentes.
Para obter detalhes sobre o novo documento criado, consulte as páginas de referência individuais para os métodos.
Se updateOne(), updateMany() ou replaceOne() incluírem upsert : true no parâmetro de documento options e nenhum documento corresponder ao filtro especificado, a operação criará um novo documento e o inserirá. Se houver documentos correspondentes, a operação modificará ou substituirá os documentos correspondentes.
Para obter detalhes sobre o novo documento criado, consulte as páginas de referência individuais para os métodos.
Se updateOne(), updateMany() ou replaceOne() incluir upsert =>
true e nenhum documento corresponder ao filtro especificado, a operação criará um novo documento e o inserirá. Se houver documentos correspondentes, a operação modificará ou substituirá os documentos correspondentes.
Para obter detalhes sobre o novo documento criado, consulte as páginas de referência individuais para os métodos.
Se update_one, update_many ou replace_one incluir upsert : true e nenhum documento corresponder ao filtro especificado, a operação criará um novo documento e o inserirá. Se houver documentos correspondentes, a operação modificará ou substituirá os documentos correspondentes.
Para obter detalhes sobre o novo documento criado, consulte as páginas de referência individuais para os métodos.
Se update_one(), update_many() ou replace_one() incluir upsert => true e nenhum documento corresponder ao filtro especificado, a operação criará um novo documento e o inserirá. Se houver documentos correspondentes, a operação modificará ou substituirá os documentos correspondentes.
Para obter detalhes sobre o novo documento criado, consulte as páginas de referência individuais para os métodos.
Se updateOne(), updateMany() ou replaceOne() incluir upsert => true e nenhum documento corresponder ao filtro especificado, a operação criará um novo documento e o inserirá. Se houver documentos correspondentes, a operação modificará ou substituirá os documentos correspondentes.
Para obter detalhes sobre o novo documento criado, consulte as páginas de referência individuais para os métodos.
Escrever confirmação
Especifique o nível de confirmação solicitado ao MongoDB para operações de gravação com preocupação de gravação.






