Docs Menu
Docs Home
/ /

Update Documents

Puede actualizar documentos utilizando:

  • El controlador de su lenguaje de programación

  • El Interfaz de usuario de MongoDB Atlas (consulte Actualizar un documento con MongoDB Atlas)

  • MongoDB Compass


➤ Use el menú desplegable Seleccione su lenguaje en la parte superior derecha para establecer el lenguaje de los siguientes ejemplos.


Esta página utiliza lo siguiente mongosh métodos:

  • db.collection.updateOne(<filter>, <update>, <options>)

  • db.collection.updateMany(<filter>, <update>, <options>)

  • db.collection.replaceOne(<filter>, <update>, <options>)

Los ejemplos usan la colección inventory. Conéctese a una base de datos de prueba en su instancia de MongoDB y luego cree la colección inventory:

Esta página utiliza MongoDB Compass para actualizar documentos.

Los ejemplos usan la colección inventory. Conéctese a una base de datos de prueba en su instancia de MongoDB y luego cree la colección inventory:

Esta página utiliza el siguiente controlador MongoDB C métodos:

Los ejemplos usan la colección inventory. Conéctese a una base de datos de prueba en su instancia de MongoDB y luego cree la colección inventory:

En esta página, se utilizan los siguientes métodos del driver C# de MongoDB:

Los ejemplos usan la colección inventory. Conéctese a una base de datos de prueba en su instancia de MongoDB y luego cree la colección inventory:

Esta página utiliza las siguientes funciones del controlador MongoDB Go:

Los ejemplos usan la colección inventory. Conéctese a una base de datos de prueba en su instancia de MongoDB y luego cree la colección inventory:

Esta página utiliza los siguientes métodos del controlador Java Reactive Streams:

Los ejemplos usan la colección inventory. Conéctese a una base de datos de prueba en su instancia de MongoDB y luego cree la colección inventory:

Esta página utiliza los siguientes métodos del controlador Java Synchronous:

Los ejemplos usan la colección inventory. Conéctese a una base de datos de prueba en su instancia de MongoDB y luego cree la colección inventory:

En esta página, se utilizan los siguientes métodos del driver corrutina de Kotlin:

Los ejemplos usan la colección inventory. Conéctese a una base de datos de prueba en su instancia de MongoDB y luego cree la colección inventory:

Esta página utiliza los siguientes métodos del controlador Motor:

Los ejemplos usan la colección inventory. Conéctese a una base de datos de prueba en su instancia de MongoDB y luego cree la colección inventory:

Esta página utiliza los siguientes métodos MongoDB Nodo.js Driver:

Los ejemplos usan la colección inventory. Conéctese a una base de datos de prueba en su instancia de MongoDB y luego cree la colección inventory:

Esta página utiliza los siguientes métodos de la biblioteca PHP de MongoDB:

Los ejemplos usan la colección inventory. Conéctese a una base de datos de prueba en su instancia de MongoDB y luego cree la colección inventory:

Esta página utiliza los siguientes métodos PyMongo del controlador de Python:

Los ejemplos usan la colección inventory. Conéctese a una base de datos de prueba en su instancia de MongoDB y luego cree la colección inventory:

Esta página utiliza los siguientes métodos del controlador Ruby de MongoDB:

Los ejemplos usan la colección inventory. Conéctese a una base de datos de prueba en su instancia de MongoDB y luego cree la colección inventory:

Esta página utiliza los siguientes métodos del controlador MongoDB Scala:

Los ejemplos usan la colección inventory. Conéctese a una base de datos de prueba en su instancia de MongoDB y luego cree la colección 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 obtener instrucciones sobre cómo insertar documentos con MongoDB Compass, consulta Inserta 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()

Para modificar los valores de campo, utilice operadores de actualización de $set campo como.

Pase un documento de actualización a los métodos de actualización:

{
<update operator>: { <field1>: <value1>, ... },
<update operator>: { <field2>: <value2>, ... },
...
}

Algunos operadores de actualización, como $set, crearán el campo si este no existe. Consultar la referencia del operador de actualización individual para más detalles.

Para actualizar un documento en Compass, pase el cursor sobre el documento de destino y haga clic en el icono del lápiz:

Haz clic en editar documento

Después de hacer clic en el icono del lápiz, el documento entra en modo de edición:

Modo de edición de documento

Ahora puedes modificar este documento si haces clic en el elemento que desees cambiar y ajustas el valor.

Para obtener instrucciones detalladas,consulte la documentación de Compass o siga el ejemplo a continuación.

Para modificar los valores de campo, utilice operadores de actualización de $set campo como.

Pase un documento de actualización a las funciones de actualización:

{
<update operator>: { <field1>: <value1>, ... },
<update operator>: { <field2>: <value2>, ... },
...
}

Algunos operadores de actualización, como $set, crearán el campo si este no existe. Consultar la referencia del operador de actualización individual para más detalles.

Para modificar los valores de campo, utilice operadores de actualización de $set campo como.

Pase un documento de actualización a los métodos de actualización:

{
<update operator> => { <field1> => <value1>, ... },
<update operator> => { <field2> => <value2>, ... },
...
}

Algunos operadores de actualización, como $set, crearán el campo si este no existe. Consultar la referencia del operador de actualización individual para más detalles.

Para modificar los valores de campo, utilice operadores de actualización de $set campo como.

Algunos operadores de actualización, como $set, crearán el campo si este no existe. Consultar la referencia del operador de actualización individual para más detalles.

Para modificar los valores de campo, utilice operadores de actualización de $set campo como.

El controlador proporciona la clase com.mongodb.client.model.Updates para crear documentos de actualización:

combine(set(<field1>, <value1>), set(<field2>, <value2>))

Para obtener una lista de los asistentes de actualización, consultar com.mongodb.client.model.Updates.

Algunos operadores de actualización, como $set, crearán el campo si este no existe. Consultar la referencia del operador de actualización individual para más detalles.

Para modificar los valores de campo, utilice operadores de actualización de $set campo como.

El controlador proporciona la clase com.mongodb.client.model.Updates para crear documentos de actualización:

combine(set(<field1>, <value1>), set(<field2>, <value2>))

Para obtener una lista de los asistentes de actualización, consultar com.mongodb.client.model.Updates.

Algunos operadores de actualización, como $set, crearán el campo si este no existe. Consultar la referencia del operador de actualización individual para más detalles.

Para modificar los valores de campo, utilice operadores de actualización de $set campo como.

El controlador proporciona la clase com.mongodb.client.model.Updates para generar documentos de actualización. El siguiente código muestra un documento de actualización que utiliza métodos de la Updates clase de generación:

combine(set(<field1>, <value1>), set(<field2>, <value2>))

Algunos operadores de actualización, como $set, crearán el campo si este no existe. Consultar la referencia del operador de actualización individual para más detalles.

Para modificar los valores de campo, utilice operadores de actualización de $set campo como.

Pase un documento de actualización a los métodos de actualización:

{
<update operator>: { <field1>: <value1>, ... },
<update operator>: { <field2>: <value2>, ... },
...
}

Algunos operadores de actualización, como $set, crearán el campo si este no existe. Consultar la referencia del operador de actualización individual para más detalles.

Para modificar los valores de campo, utilice operadores de actualización de $set campo como.

Pase un documento de actualización a los métodos de actualización:

{
<update operator>: { <field1>: <value1>, ... },
<update operator>: { <field2>: <value2>, ... },
...
}

Algunos operadores de actualización, como $set, crearán el campo si este no existe. Consultar la referencia del operador de actualización individual para más detalles.

Para modificar los valores de campo, utilice operadores de actualización de $set campo como.

Pase un documento de actualización a los métodos de actualización:

[
<update operator> => [ <field1> => <value1>, ... ],
<update operator> => [ <field2> => <value2>, ... ],
...
]

Algunos operadores de actualización, como $set, crearán el campo si este no existe. Consultar la referencia del operador de actualización individual para más detalles.

Para modificar los valores de campo, utilice operadores de actualización de $set campo como.

Pase un documento de actualización a los métodos de actualización:

{
<update operator>: { <field1>: <value1>, ... },
<update operator>: { <field2>: <value2>, ... },
...
}

Algunos operadores de actualización, como $set, crearán el campo si este no existe. Consultar la referencia del operador de actualización individual para más detalles.

Para modificar los valores de campo, utilice operadores de actualización de $set campo como.

Pase un documento de actualización a los métodos de actualización:

{
<update operator> => { <field1> => <value1>, ... },
<update operator> => { <field2> => <value2>, ... },
...
}

Algunos operadores de actualización, como $set, crearán el campo si este no existe. Consultar la referencia del operador de actualización individual para más detalles.

Para modificar los valores de campo, utilice operadores de actualización de $set campo como.

Pase un documento de actualización a los métodos de actualización:

(
set (<field1>, <value1>),
set (<field2>, <value2>),
...
)

Algunos operadores de actualización, como $set, crearán el campo si este no existe. Consultar la referencia del operador de actualización individual para más detalles.

Nota

MongoDB puede aceptar una canalización de agregación en lugar de un documento de actualización. Para más información, consulte la página de referencia de métodos.

En el siguiente ejemplo, se utiliza el método db.collection.updateOne() en la colección inventory para actualizar el primer documento donde item es igual a "paper":

El siguiente ejemplo demuestra cómo usar MongoDB Compass para modificar un único documento donde item: paper en la colección inventory:

Nota

Este ejemplo utiliza la Vista de tabla de Compass para modificar el documento. El proceso de edición usando la Vista de lista de Compass sigue un enfoque similar.

Para obtener más información sobre las diferencias entre la vista de tabla y la vista de lista en Compass, consulta la documentación de Compass.

El siguiente ejemplo utiliza la función mongoc_collection_update_one en la inventory colección para actualizar el primer documento donde es item igual "paper" a:

El siguiente ejemplo utiliza el método IMongoCollection.UpdateOne() en la colección inventory para actualizar el primer documento donde item es igual a "paper":

El siguiente ejemplo utiliza el método Collection.UpdateOne en la colección inventory para actualizar el primer documento donde item es igual a "paper":

El siguiente ejemplo utiliza com.mongodb.reactivestreams.client.MongoCollection.actualizarOne en la colección inventory para actualizar el primer documento donde item sea igual a "paper":

El siguiente ejemplo utiliza el método com.mongodb.cliente.MongoCollection.updateOne en la colección inventory para actualizar el primer documento donde item es igual a "paper":

El siguiente ejemplo utiliza el método MongoCollection.updateOne() en la colección inventory para actualizar el primer documento donde item sea igual a "paper":

El siguiente ejemplo utiliza el método update_one en la colección inventory para actualizar el primer documento donde item es igual a "paper":

El siguiente ejemplo utiliza el método Collection.updateOne() en la colección inventory para actualizar el primer documento donde item sea igual a "paper":

En el siguiente ejemplo, se utiliza el método updateOne() en la colección inventory para actualizar el primer documento donde item es igual a "paper":

El siguiente ejemplo utiliza el método update_one en la colección inventory para actualizar el primer documento donde item es igual a "paper":

El siguiente ejemplo utiliza el método update_one() en la colección inventory para actualizar el primer documento donde item sea igual a "paper":

El siguiente ejemplo utiliza el método updateOne() en la colección inventory para actualizar el primer documento donde item sea igual a "paper":

db.inventory.updateOne(
{ item: "paper" },
{
$set: { "size.uom": "cm", status: "P" },
$currentDate: { lastModified: true }
}
)

La operación de actualización:

  • utiliza el operador $set para actualizar el valor del campo size.uom a "cm" y el valor del campo status a "P",

  • utiliza el operador $currentDate para actualizar el valor del campo lastModified a la fecha actual. Si el campo lastModified no existe, $currentDate creará el campo. Consulta $currentDate para obtener más detalles.

Modifique el documento de destino de la siguiente manera:

  • Cambie el campo status de D a P.

  • Cambie el campo size.uom de in a cm.

  • Añada un nuevo campo llamado lastModified cuyo valor será la fecha de hoy.

  1. Haga clic en el Table Botón en la navegación superior para acceder a la Vista de Tabla:

    Acceder a la Vista de Tabla
  2. Utiliza la barra de query de Compass para localizar el documento de destino.

    Copia el siguiente documento de filtro en la barra de query y haz clic en Find:

    { item: "paper" }
    Buscar documento de Paper
  3. Pasa el cursor sobre el campo status y haz clic en el icono del lápiz que aparece en el lado derecho del documento para entrar en el modo de edición:

    Haga clic en el botón de editar
  4. Cambia el valor del campo a "P".

  5. Hacer clic en el botón Update debajo del campo para guardar los cambios.

  6. Pasa el cursor sobre el campo size y haz clic en las flechas que apuntan hacia afuera que aparecen en el lado derecho del campo. Esto abre una nueva pestaña que muestra los campos dentro del objeto size:

    Ampliar el tamaño del objeto
  7. Sigue el mismo proceso descrito en los pasos 3-5 para editar el campo status y cambia el valor del campo size.uom a "cm".

  8. Haz clic en la pestaña más a la izquierda sobre la tabla etiquetada inventory para regresar a la vista original de la tabla, que muestra el documento principal:

    Haga clic en la pestaña de inventario
  9. Pasa el cursor sobre el campo status y haz clic en el icono de lápiz que aparece en el lado derecho del documento para volver a entrar en el modo de edición.

  10. Haz clic dentro del campo status y luego en el icono plus button que aparece en el menú de edición.

    Haz clic en el botón Add Field After status que aparece debajo del botón más:

    Añada un campo después del estado
  11. Agrega un nuevo campo llamado lastModified con el valor de la fecha de hoy. Establece el tipo de campo en Date:

    Enviar actualización
  12. Hacer clic en el botón Update debajo del campo para guardar los cambios.

    Nota

    Debido a que MongoDB Compass no admite $currentDate ni ningún otro operador de actualización de campos, deberás introducir manualmente el valor de la fecha en 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);

La operación de actualización:

  • utiliza el operador $set para actualizar el valor del campo size.uom a "cm" y el valor del campo status a "P",

  • utiliza el operador $currentDate para actualizar el valor del campo lastModified a la fecha actual. Si el campo lastModified no existe, $currentDate creará el campo. Consulta $currentDate para obtener más detalles.

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},
}},
},
)

La operación de actualización:

  • utiliza el operador $set para actualizar el valor del campo size.uom a "cm" y el valor del campo status a "P",

  • utiliza el operador $currentDate para actualizar el valor del campo lastModified a la fecha actual. Si el campo lastModified no existe, $currentDate creará el campo. Consulta $currentDate para obtener más detalles.

Publisher<UpdateResult> updateOnePublisher = collection.updateOne(eq("item", "paper"),
combine(set("size.uom", "cm"), set("status", "P"), currentDate("lastModified")));

La operación de actualización:

  • utiliza el operador $set para actualizar el valor del campo size.uom a "cm" y el valor del campo status a "P",

  • utiliza el operador $currentDate para actualizar el valor del campo lastModified a la fecha actual. Si el campo lastModified no existe, $currentDate creará el campo. Consulta $currentDate para obtener más detalles.

collection.updateOne(eq("item", "paper"),
combine(set("size.uom", "cm"), set("status", "P"), currentDate("lastModified")));

La operación de actualización:

  • utiliza el operador $set para actualizar el valor del campo size.uom a "cm" y el valor del campo status a "P",

  • utiliza el operador $currentDate para actualizar el valor del campo lastModified a la fecha actual. Si el campo lastModified no existe, $currentDate creará el campo. Consulta $currentDate para obtener más detalles.

collection.updateOne(eq("item", "paper"),
combine(set("size.uom", "cm"), set("status", "P"), currentDate("lastModified")));

La operación de actualización:

  • utiliza el operador $set para actualizar el valor del campo size.uom a "cm" y el valor del campo status a "P",

  • utiliza el operador $currentDate para actualizar el valor del campo lastModified a la fecha actual. Si el campo lastModified no existe, $currentDate creará el campo. Consulta $currentDate para obtener más detalles.

await db.inventory.update_one(
{"item": "paper"},
{"$set": {"size.uom": "cm", "status": "P"}, "$currentDate": {"lastModified": True}},
)

La operación de actualización:

  • utiliza el operador $set para actualizar el valor del campo size.uom a "cm" y el valor del campo status a "P",

  • utiliza el operador $currentDate para actualizar el valor del campo lastModified a la fecha actual. Si el campo lastModified no existe, $currentDate creará el campo. Consulta $currentDate para obtener más detalles.

await db.collection('inventory').updateOne(
{ item: 'paper' },
{
$set: { 'size.uom': 'cm', status: 'P' },
$currentDate: { lastModified: true }
}
);

La operación de actualización:

  • utiliza el operador $set para actualizar el valor del campo size.uom a "cm" y el valor del campo status a "P",

  • utiliza el operador $currentDate para actualizar el valor del campo lastModified a la fecha actual. Si el campo lastModified no existe, $currentDate creará el campo. Consulta $currentDate para obtener más detalles.

$updateResult = $db->inventory->updateOne(
['item' => 'paper'],
[
'$set' => ['size.uom' => 'cm', 'status' => 'P'],
'$currentDate' => ['lastModified' => true],
],
);

La operación de actualización:

  • utiliza el operador $set para actualizar el valor del campo size.uom a "cm" y el valor del campo status a "P",

  • utiliza el operador $currentDate para actualizar el valor del campo lastModified a la fecha actual. Si el campo lastModified no existe, $currentDate creará el campo. Consulta $currentDate para obtener más detalles.

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 } })

La operación de actualización:

  • utiliza el operador $set para actualizar el valor del campo size.uom a "cm" y el valor del campo status a "P",

  • utiliza el operador $currentDate para actualizar el valor del campo lastModified a la fecha actual. Si el campo lastModified no existe, $currentDate creará el campo. Consulta $currentDate para obtener más detalles.

collection.updateOne(equal("item", "paper"),
combine(set("size.uom", "cm"), set("status", "P"), currentDate("lastModified"))
).execute()

La operación de actualización:

  • utiliza el operador $set para actualizar el valor del campo size.uom a "cm" y el valor del campo status a "P",

  • utiliza el operador $currentDate para actualizar el valor del campo lastModified a la fecha actual. Si el campo lastModified no existe, $currentDate creará el campo. Consulta $currentDate para obtener más detalles.

En el siguiente ejemplo, se utiliza el método db.collection.updateMany() en la colección inventory para actualizar todos los documentos donde qty es menor que 50:

Puede actualizar solo un documento a la vez en MongoDB Compass.

El siguiente ejemplo utiliza la función mongoc_collection_update_many en la inventory colección para actualizar todos los documentos donde qty es menor 50 que:

El siguiente ejemplo utiliza el método IMongoCollection.UpdateMany() en la colección inventory para actualizar todos los documentos donde qty sea menor que 50:

El siguiente ejemplo utiliza el método Collection.UpdateMany en la colección inventory para actualizar todos los documentos donde qty es menor que 50:

El siguiente ejemplo utiliza el método com.mongodb.reactivestreams.client.MongoCollection.updateMany en la colección inventory para actualizar todos los documentos donde qty es menor que 50:

El siguiente ejemplo utiliza el método com.mongodb.client.MongoCollection.updateMany en la colección inventory para actualizar todos los documentos donde qty sea menor que 50:

El siguiente ejemplo utiliza el método MongoCollection.updateMany() en la colección inventory para actualizar todos los documentos donde qty sea menor que 50:

El siguiente ejemplo utiliza el método update_many en la colección inventory para actualizar todos los documentos donde qty es menor que 50:

El siguiente ejemplo utiliza el método colección.updateMany() en la colección inventory para actualizar todos los documentos donde qty sea menor que 50:

En el siguiente ejemplo, se utiliza el método updateMany() en la colección inventory para actualizar todos los documentos donde qty es menor que 50:

El siguiente ejemplo utiliza el método update_many en la colección inventory para actualizar todos los documentos donde qty es menor que 50:

El siguiente ejemplo utiliza el método update_many() en la colección inventory para actualizar todos los documentos donde qty sea menor que 50:

El siguiente ejemplo utiliza el método updateMany() en la colección inventory para actualizar todos los documentos donde qty es menor que 50:

db.inventory.updateMany(
{ "qty": { $lt: 50 } },
{
$set: { "size.uom": "in", status: "P" },
$currentDate: { lastModified: true }
}
)

La operación de actualización:

  • utiliza el operador $set para actualizar el valor del campo size.uom a "in" y el valor del campo status a "P",

  • utiliza el operador $currentDate para actualizar el valor del campo lastModified a la fecha actual. Si el campo lastModified no existe, $currentDate creará el campo. Consulta $currentDate para obtener más detalles.

Para actualizar varios documentos, conecte su implementación de MongoDB desde mongosh o un controlador de MongoDB y siga los ejemplos de esta sección para su método preferido.

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);

La operación de actualización:

  • utiliza el operador $set para actualizar el valor del campo size.uom a "in" y el valor del campo status a "P",

  • utiliza el operador $currentDate para actualizar el valor del campo lastModified a la fecha actual. Si el campo lastModified no existe, $currentDate creará el campo. Consulta $currentDate para obtener más detalles.

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},
}},
},
)

La operación de actualización:

  • utiliza el operador $set para actualizar el valor del campo size.uom a "in" y el valor del campo status a "P",

  • utiliza el operador $currentDate para actualizar el valor del campo lastModified a la fecha actual. Si el campo lastModified no existe, $currentDate creará el campo. Consulta $currentDate para obtener más detalles.

Publisher<UpdateResult> updateManyPublisher = collection.updateMany(lt("qty", 50),
combine(set("size.uom", "in"), set("status", "P"), currentDate("lastModified")));

La operación de actualización:

  • utiliza el operador $set para actualizar el valor del campo size.uom a "in" y el valor del campo status a "P",

  • utiliza el operador $currentDate para actualizar el valor del campo lastModified a la fecha actual. Si el campo lastModified no existe, $currentDate creará el campo. Consulta $currentDate para obtener más detalles.

collection.updateMany(lt("qty", 50),
combine(set("size.uom", "in"), set("status", "P"), currentDate("lastModified")));

La operación de actualización:

  • utiliza el operador $set para actualizar el valor del campo size.uom a "in" y el valor del campo status a "P",

  • utiliza el operador $currentDate para actualizar el valor del campo lastModified a la fecha actual. Si el campo lastModified no existe, $currentDate creará el campo. Consulta $currentDate para obtener más detalles.

collection.updateOne(eq("item", "paper"),
combine(set("size.uom", "cm"), set("status", "P"), currentDate("lastModified")));

La operación de actualización:

  • utiliza el operador $set para actualizar el valor del campo size.uom a "in" y el valor del campo status a "P",

  • utiliza el operador $currentDate para actualizar el valor del campo lastModified a la fecha actual. Si el campo lastModified no existe, $currentDate creará el campo. Consulta $currentDate para obtener más detalles.

await db.inventory.update_many(
{"qty": {"$lt": 50}},
{"$set": {"size.uom": "in", "status": "P"}, "$currentDate": {"lastModified": True}},
)

La operación de actualización:

  • utiliza el operador $set para actualizar el valor del campo size.uom a "in" y el valor del campo status a "P",

  • utiliza el operador $currentDate para actualizar el valor del campo lastModified a la fecha actual. Si el campo lastModified no existe, $currentDate creará el campo. Consulta $currentDate para obtener más detalles.

await db.collection('inventory').updateMany(
{ qty: { $lt: 50 } },
{
$set: { 'size.uom': 'in', status: 'P' },
$currentDate: { lastModified: true }
}
);

La operación de actualización:

  • utiliza el operador $set para actualizar el valor del campo size.uom a "in" y el valor del campo status a "P",

  • utiliza el operador $currentDate para actualizar el valor del campo lastModified a la fecha actual. Si el campo lastModified no existe, $currentDate creará el campo. Consulta $currentDate para obtener más detalles.

$updateResult = $db->inventory->updateMany(
['qty' => ['$lt' => 50]],
[
'$set' => ['size.uom' => 'cm', 'status' => 'P'],
'$currentDate' => ['lastModified' => true],
],
);

La operación de actualización:

  • utiliza el operador $set para actualizar el valor del campo size.uom a "in" y el valor del campo status a "P",

  • utiliza el operador $currentDate para actualizar el valor del campo lastModified a la fecha actual. Si el campo lastModified no existe, $currentDate creará el campo. Consulta $currentDate para obtener más detalles.

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 } })

La operación de actualización:

  • utiliza el operador $set para actualizar el valor del campo size.uom a "in" y el valor del campo status a "P",

  • utiliza el operador $currentDate para actualizar el valor del campo lastModified a la fecha actual. Si el campo lastModified no existe, $currentDate creará el campo. Consulta $currentDate para obtener más detalles.

collection.updateMany(lt("qty", 50),
combine(set("size.uom", "in"), set("status", "P"), currentDate("lastModified"))
).execute()

La operación de actualización:

  • utiliza el operador $set para actualizar el valor del campo size.uom a "in" y el valor del campo status a "P",

  • utiliza el operador $currentDate para actualizar el valor del campo lastModified a la fecha actual. Si el campo lastModified no existe, $currentDate creará el campo. Consulta $currentDate para obtener más detalles.

Para reemplazar todo el contenido de un documento excepto el campo _id, pasa un documento completamente nuevo como segundo argumento a db.collection.replaceOne().

Al reemplazar un documento, el documento de reemplazo debe consistir únicamente en pares de campo/valor. El documento de reemplazo no puede incluir expresiones de operadores de actualización.

El documento de reemplazo puede tener campos distintos a los del documento original. En el documento de reemplazo, puedes omitir el campo _id ya que el campo _id es inmutable. Sin embargo, si incluyes el campo _id, debe tener el mismo valor que el valor actual.

En el siguiente ejemplo, se reemplaza el primer documento de la colección inventory donde item: "paper":

No es posible reemplazar un documento en MongoDB Compass.

Para reemplazar todo el contenido de un documento excepto el _id campo, pase un documento completamente nuevo como tercer argumento a mongoc_collection_replace_one.

Al reemplazar un documento, el documento de reemplazo debe consistir únicamente en pares de campo/valor. El documento de reemplazo no puede incluir expresiones de operadores de actualización.

El documento de reemplazo puede tener campos distintos a los del documento original. En el documento de reemplazo, puedes omitir el campo _id ya que el campo _id es inmutable. Sin embargo, si incluyes el campo _id, debe tener el mismo valor que el valor actual.

En el siguiente ejemplo, se reemplaza el primer documento de la colección inventory donde item: "paper":

Para reemplazar todo el contenido de un documento excepto el campo _id, pasa un documento completamente nuevo como segundo argumento a IMongoCollection.ReplaceOne().

Al reemplazar un documento, el documento de reemplazo debe consistir únicamente en pares de campo/valor. El documento de reemplazo no puede incluir expresiones de operadores de actualización.

El documento de reemplazo puede tener campos distintos a los del documento original. En el documento de reemplazo, puedes omitir el campo _id ya que el campo _id es inmutable. Sin embargo, si incluyes el campo _id, debe tener el mismo valor que el valor actual.

En el siguiente ejemplo, se reemplaza el primer documento de la colección inventory donde item: "paper":

Para reemplazar todo el contenido de un documento excepto por el campo _id, pasa un documento completamente nuevo como segundo argumento a Colección.ReplaceOne.

Al reemplazar un documento, el documento de reemplazo debe consistir únicamente en pares de campo/valor. El documento de reemplazo no puede incluir expresiones de operadores de actualización.

El documento de reemplazo puede tener campos distintos a los del documento original. En el documento de reemplazo, puedes omitir el campo _id ya que el campo _id es inmutable. Sin embargo, si incluyes el campo _id, debe tener el mismo valor que el valor actual.

En el siguiente ejemplo, se reemplaza el primer documento de la colección inventory donde item: "paper":

Para reemplazar todo el contenido de un documento excepto el campo _id, pasar un documento completamente nuevo como segundo argumento a com.mongodb.reactivestreams.client.MongoCollection.replaceOne.

Al reemplazar un documento, el documento de reemplazo debe consistir únicamente en pares de campo/valor. El documento de reemplazo no puede incluir expresiones de operadores de actualización.

El documento de reemplazo puede tener campos distintos a los del documento original. En el documento de reemplazo, puedes omitir el campo _id ya que el campo _id es inmutable. Sin embargo, si incluyes el campo _id, debe tener el mismo valor que el valor actual.

En el siguiente ejemplo, se reemplaza el primer documento de la colección inventory donde item: "paper":

Para reemplazar todo el contenido de un documento excepto el campo _id, pasar un documento completamente nuevo como segundo argumento a com.mongodb.client.MongoCollection.replaceOne.

Al reemplazar un documento, el documento de reemplazo debe consistir únicamente en pares de campo/valor. El documento de reemplazo no puede incluir expresiones de operadores de actualización.

El documento de reemplazo puede tener campos distintos a los del documento original. En el documento de reemplazo, puedes omitir el campo _id ya que el campo _id es inmutable. Sin embargo, si incluyes el campo _id, debe tener el mismo valor que el valor actual.

En el siguiente ejemplo, se reemplaza el primer documento de la colección inventory donde item: "paper":

Para reemplazar todo el contenido de un documento excepto por el campo _id, pasa un documento completamente nuevo como segundo argumento a MongoCollection.replaceOne() método.

Al reemplazar un documento, el documento de reemplazo debe consistir únicamente en pares de campo/valor. El documento de reemplazo no puede incluir expresiones de operadores de actualización.

El documento de reemplazo puede tener campos distintos a los del documento original. En el documento de reemplazo, puedes omitir el campo _id ya que el campo _id es inmutable. Sin embargo, si incluyes el campo _id, debe tener el mismo valor que el valor actual.

En el siguiente ejemplo, se reemplaza el primer documento de la colección inventory donde item: "paper":

Para reemplazar todo el contenido de un documento excepto el campo _id, pasa un documento completamente nuevo como segundo argumento a replace_one.

Al reemplazar un documento, el documento de reemplazo debe consistir únicamente en pares de campo/valor. El documento de reemplazo no puede incluir expresiones de operadores de actualización.

El documento de reemplazo puede tener campos distintos a los del documento original. En el documento de reemplazo, puedes omitir el campo _id ya que el campo _id es inmutable. Sin embargo, si incluyes el campo _id, debe tener el mismo valor que el valor actual.

En el siguiente ejemplo, se reemplaza el primer documento de la colección inventory donde item: "paper":

Para reemplazar todo el contenido de un documento excepto el campo _id, pasa un documento completamente nuevo como segundo argumento a colección.replaceOne().

Al reemplazar un documento, el documento de reemplazo debe consistir únicamente en pares de campo/valor. El documento de reemplazo no puede incluir expresiones de operadores de actualización.

El documento de reemplazo puede tener campos distintos a los del documento original. En el documento de reemplazo, puedes omitir el campo _id ya que el campo _id es inmutable. Sin embargo, si incluyes el campo _id, debe tener el mismo valor que el valor actual.

En el siguiente ejemplo, se reemplaza el primer documento de la colección inventory donde item: "paper":

Para reemplazar todo el contenido de un documento excepto el campo _id, pasa un documento completamente nuevo como segundo argumento a replaceOne().

Al reemplazar un documento, el documento de reemplazo debe consistir únicamente en pares de campo/valor. El documento de reemplazo no puede incluir expresiones de operadores de actualización.

El documento de reemplazo puede tener campos distintos a los del documento original. En el documento de reemplazo, puedes omitir el campo _id ya que el campo _id es inmutable. Sin embargo, si incluyes el campo _id, debe tener el mismo valor que el valor actual.

En el siguiente ejemplo, se reemplaza el primer documento de la colección inventory donde item: "paper":

Para reemplazar todo el contenido de un documento excepto el campo _id, pasa un documento completamente nuevo como segundo argumento a replace_one.

Al reemplazar un documento, el documento de reemplazo debe consistir únicamente en pares de campo/valor. El documento de reemplazo no puede incluir expresiones de operadores de actualización.

El documento de reemplazo puede tener campos distintos a los del documento original. En el documento de reemplazo, puedes omitir el campo _id ya que el campo _id es inmutable. Sin embargo, si incluyes el campo _id, debe tener el mismo valor que el valor actual.

En el siguiente ejemplo, se reemplaza el primer documento de la colección inventory donde item: "paper":

Para reemplazar todo el contenido de un documento excepto por el campo _id, pasa un documento completamente nuevo como segundo argumento a replace_one().

Al reemplazar un documento, el documento de reemplazo debe consistir únicamente en pares de campo/valor. El documento de reemplazo no puede incluir expresiones de operadores de actualización.

El documento de reemplazo puede tener campos distintos a los del documento original. En el documento de reemplazo, puedes omitir el campo _id ya que el campo _id es inmutable. Sin embargo, si incluyes el campo _id, debe tener el mismo valor que el valor actual.

En el siguiente ejemplo, se reemplaza el primer documento de la colección inventory donde item: "paper":

Para reemplazar todo el contenido de un documento excepto el campo _id, pasar un documento completamente nuevo como segundo argumento a replaceOne()

Al reemplazar un documento, el documento de reemplazo debe consistir únicamente en pares de campo/valor. El documento de reemplazo no puede incluir expresiones de operadores de actualización.

El documento de reemplazo puede tener campos distintos a los del documento original. En el documento de reemplazo, puedes omitir el campo _id ya que el campo _id es inmutable. Sin embargo, si incluyes el campo _id, debe tener el mismo valor que el valor actual.

En el siguiente ejemplo, se reemplaza el primer documento de la colección inventory donde item: "paper":

db.inventory.replaceOne(
{ item: "paper" },
{ item: "paper", instock: [ { warehouse: "A", qty: 60 }, { warehouse: "B", qty: 40 } ] }
)

Para reemplazar un documento, conéctese a su implementación de MongoDB desde o un controlador de MongoDB y siga los ejemplos de esta sección para su método mongosh preferido.

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;
}

Limpie cualquier recurso abierto llamando a los siguientes métodos, según corresponda:

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()

Nota

La interfaz de usuario de MongoDB Atlas actualiza un documento a la vez. Para actualizar varios documentos o reemplazar uno completo, conéctese a su implementación de Atlas desde mongosh o un controlador de MongoDB y siga el ejemplo para su método preferido.

Este ejemplo utiliza el conjunto de datos de muestra "Suministros". Para cargarlo, consulte "Cargar datos de muestra".

Para actualizar un documento en MongoDB Atlas, siga estos pasos:

1
  1. Si aún no se muestra, seleccione la organización que contiene su proyecto deseado en el menú Organizations de la barra de navegación.

  2. Si aún no se muestra, seleccione su proyecto en el menú Projects de la barra de navegación.

  3. En la barra lateral, haz clic en Clusters en la sección Database.

    La página de clústeres se muestra.

2
  1. Para el clúster que contiene los datos de muestra, haz clic en Browse Collections.

  2. En el panel de navegación izquierdo, seleccione la base de datos sample_supplies.

  3. Seleccione la colección sales.

3

Puede especificar un documento de filtro de query en el campo Filter. Un documento de filtro de query utiliza operadores del query para especificar condiciones de búsqueda.

Copia el siguiente documento de filtro de query en la barra de búsqueda Filter y haz clic en Apply:

{ saleDate: { $gte: { $date: "2016-01-01T00:00-00:00" }, $lte: { $date: "2016-01-02T00:00-00:00" } } }

Este filtro de query devuelve todos los documentos de la colección sample_supplies.sales donde saleDate está entre el 1 y el 2 de enero de 2016, hora UTC.

4

Para editar un documento que aparece en los resultados del query, pasa el ratón sobre el documento y haz clic en el icono del lápiz. En el editor de documentos, puedes:

  • Añade un nuevo campo.

  • Borrar un campo existente.

  • Edita el nombre, el valor o el tipo de un campo.

  • Revertir un cambio específico.

Para obtener instrucciones detalladas, consultar Crear, ver, actualizar y borrar documentos.

5

Para confirmar y guardar los cambios, haz clic en el botón Update.

Todas las operaciones de escritura son atómicas a nivel de documento. Para más información, consulte Atomicidad y Transacciones.

Una vez configurado, no puede actualizar el valor del campo _id ni puede reemplazar un documento con uno que tenga un valor _id diferente.

Utilice updateMany() sólo para operaciones idempotentes.

Para las operaciones de guardado, MongoDB conserva el orden de los campos del documento excepto en los siguientes casos:

  • El campo _id siempre es el primer campo del documento.

  • Las actualizaciones que incluyen renaming de los nombres de campo pueden resultar en el reordenamiento de los campos en el documento.

Si updateOne(), updateMany() o replaceOne() incluye upsert : true y ningún documento coincide con el filtro especificado, entonces la operación crea un nuevo documento y lo inserta. Si hay documentos que coinciden, la operación modifica o reemplaza dichos documentos.

Para obtener detalles sobre el nuevo documento creado, consulta las páginas de referencia individuales de los métodos.

La opción upsert no está disponible en MongoDB Compass.

Si mongoc_collection_update_one, mongoc_collection_update_many, o mongoc_collection_replace_one incluye upsert : true y ningún documento coincide con el filtro especificado, entonces la operación crea e inserta un nuevo documento. Si hay documentos coincidentes, la operación modifica o sustituye el documento o documentos coincidentes.

Para obtener detalles sobre el nuevo documento creado, consulte las páginas de referencia individuales para las funciones.

Si UpdateOne(), UpdateMany(), o ReplaceOne() incluye una instancia de argumento de UpdateOptions con la opción IsUpsert establecida en true y ningún documento coincide con el filtro especificado, entonces la operación crea un nuevo documento y lo inserta. Si hay documentos coincidentes, entonces la operación modifica o reemplaza el documento o los documentos coincidentes.

Para obtener detalles sobre el nuevo documento creado, consulta las páginas de referencia individuales de los métodos.

Si Collection.UpdateOne incluye la opción de inserción establecida en true y ningún documento coincide con el filtro especificado, entonces la operación crea un nuevo documento y lo inserta. Si hay documentos coincidentes, entonces la operación modifica o reemplaza el documento o los documentos coincidentes.

Para obtener detalles sobre el nuevo documento creado, consulta las páginas de referencia individuales de los métodos.

Si los métodos de actualización y reemplazo incluyen el parámetro UpdateOptions que especifica UpdateOptions.upsert(true) y ningún documento coincide con el filtro especificado, entonces la operación crea un nuevo documento y lo inserta. Si hay documentos coincidentes, entonces la operación modifica o reemplaza el documento o los documentos coincidentes.

Para obtener detalles sobre el nuevo documento creado, consulta las páginas de referencia individuales de los métodos.

Si los métodos de actualización y reemplazo incluyen el parámetro com.mongodb.client.model.UpdateOptions que especifica com.mongodb.client.model.UpdateOptions.upsert(true) y si ningún documento coincide con el filtro especificado, entonces la operación crea un nuevo documento y lo inserta. Si hay documentos coincidentes, entonces la operación modifica o reemplaza el documento o los documentos coincidentes.

Para obtener detalles sobre el nuevo documento creado, consulta las páginas de referencia individuales de los métodos.

Si los métodos de actualización y reemplazo incluyen el parámetro com.mongodb.client.model.UpdateOptions que especifica upsert(true), y ningún documento coincide con el filtro especificado, entonces la operación crea un nuevo documento y lo inserta. Si hay documentos coincidentes, entonces la operación modifica o reemplaza el documento o los documentos coincidentes.

Para obtener detalles sobre el nuevo documento creado, consulta las páginas de referencia individuales de los métodos.

Si update_one, update_many, o replace_one incluye upsert : true y ningún documento coincide con el filtro especificado, entonces la operación crea un nuevo documento y lo inserta. Si hay documentos coincidentes, entonces la operación modifica o reemplaza el documento o los documentos coincidentes.

Para obtener detalles sobre el nuevo documento creado, consulta las páginas de referencia individuales de los métodos.

Si updateOne(), updateMany(), o replaceOne() incluyen upsert : true en el documento del parámetro options y ningún documento coincide con el filtro especificado, entonces la operación crea un nuevo documento y lo inserta. Si hay documentos coincidentes, entonces la operación modifica o reemplaza el documento o los documentos coincidentes.

Para obtener detalles sobre el nuevo documento creado, consulta las páginas de referencia individuales de los métodos.

Si updateOne(), updateMany() o replaceOne() incluye upsert => true y ningún documento coincide con el filtro especificado, entonces la operación crea un nuevo documento y lo inserta. Si hay documentos que coinciden, la operación modifica o reemplaza dichos documentos.

Para obtener detalles sobre el nuevo documento creado, consulta las páginas de referencia individuales de los métodos.

Si update_one, update_many, o replace_one incluye upsert : true y ningún documento coincide con el filtro especificado, entonces la operación crea un nuevo documento y lo inserta. Si hay documentos coincidentes, entonces la operación modifica o reemplaza el documento o los documentos coincidentes.

Para obtener detalles sobre el nuevo documento creado, consulta las páginas de referencia individuales de los métodos.

Si update_one(), update_many() o replace_one() incluye upsert => true y ningún documento coincide con el filtro especificado, entonces la operación crea un nuevo documento y lo inserta. Si hay documentos coincidentes, entonces la operación modifica o reemplaza el documento o los documentos coincidentes.

Para obtener detalles sobre el nuevo documento creado, consulta las páginas de referencia individuales de los métodos.

Si updateOne(), updateMany() o replaceOne() incluye upsert => true y ningún documento coincide con el filtro especificado, entonces la operación crea un documento nuevo y lo inserta. Si hay documentos coincidentes, entonces la operación modifica o reemplaza el documento o los documentos coincidentes.

Para obtener detalles sobre el nuevo documento creado, consulta las páginas de referencia individuales de los métodos.

Especifica el nivel de reconocimiento solicitado a MongoDB para las operaciones de escritura con niveles de confirmación de escritura (write concerns).

Tip

Volver

Realice consultas de snapshots de larga duración

En esta página