Docs 菜单
Docs 主页
/
MongoDB Manual
/

Update Documents

在此页面上

  • 更新集合中的文档
  • 使用 MongoDB Atlas 更新文档
  • 行为

您可以使用以下方法更新 MongoDB 中的文档:

  • 您的编程语言的驱动程序。

  • MongoDB Atlas 用户界面 。要了解更多信息,请参阅使用 MongoDB Atlas 更新文档

  • MongoDB Compass。


➤ 使用右上角的 Select your language(选择语言)下拉菜单,设置以下示例的语言。


本页面使用以下 mongosh 方法:

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

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

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

此页面上的示例使用的是 inventory 集合。连接到 MongoDB 实例中的测试数据库,然后创建 inventory 集合:

本页面使用 MongoDB Compass 更新文档。

此页面上的示例使用的是 inventory 集合。使用以下文档填充 inventory 集合:

此页面使用以下 MongoDB C驱动程序 方法:

此页面上的示例使用的是 inventory 集合。连接到 MongoDB 实例中的测试数据库,然后创建 inventory 集合:

此页面使用以下 MongoDB C# 驱动程序方法:

此页面上的示例使用的是 inventory 集合。连接到 MongoDB 实例中的测试数据库,然后创建 inventory 集合:

此页面使用以下 MongoDB Go 驱动程序 函数:

此页面上的示例使用的是 inventory 集合。连接到 MongoDB 实例中的测试数据库,然后创建 inventory 集合:

本页面使用以下 Java Reactive Streams 驱动程序方法:

此页面上的示例使用的是 inventory 集合。连接到 MongoDB 实例中的测试数据库,然后创建 inventory 集合:

此页面使用以下 Java 同步驱动程序 方法:

此页面上的示例使用的是 inventory 集合。连接到 MongoDB 实例中的测试数据库,然后创建 inventory 集合:

此页面使用以下Kotlin协程驱动程序方法:

此页面上的示例使用的是 inventory 集合。连接到 MongoDB 实例中的测试数据库,然后创建 inventory 集合:

此页面使用以下 Motor 驱动程序方法:

此页面上的示例使用的是 inventory 集合。连接到 MongoDB 实例中的测试数据库,然后创建 inventory 集合:

此页面使用以下 MongoDB Node.js 驱动程序 方法:

此页面上的示例使用的是 inventory 集合。连接到 MongoDB 实例中的测试数据库,然后创建 inventory 集合:

此页面使用以下 MongoDB Perl 驱动程序 方法:

此页面上的示例使用的是 inventory 集合。连接到 MongoDB 实例中的测试数据库,然后创建 inventory 集合:

本页面使用以下 MongoDB PHP 库方法:

此页面上的示例使用的是 inventory 集合。连接到 MongoDB 实例中的测试数据库,然后创建 inventory 集合:

本页面使用以下 PyMongo Python 驱动方法:

此页面上的示例使用的是 inventory 集合。连接到 MongoDB 实例中的测试数据库,然后创建 inventory 集合:

此页面使用以下 MongoDB Ruby 驱动程序方法:

此页面上的示例使用的是 inventory 集合。连接到 MongoDB 实例中的测试数据库,然后创建 inventory 集合:

此页面使用以下 MongoDB Scala 驱动程序 方法:

此页面上的示例使用的是 inventory 集合。连接到 MongoDB 实例中的测试数据库,然后创建 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" }
]

有关使用 MongoDB Compass 插入文档的说明,请参阅插入文档

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 := []interface{}{
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'
}
]);
$db->coll("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"
}
]
);
$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()

要更新文档,MongoDB 提供 $set更新操作符来修改字段值。

要使用更新操作符,请向更新方法传递以下形式的更新文档:

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

某些更新操作符(例如 $set)会在字段不存在的情况下创建字段。有关详细信息,请参阅相应的更新操作符参考信息。

要在 Compass 中更新文档,请将鼠标悬停在目标文档上,然后单击铅笔图标:

单击编辑文档

单击铅笔图标后,文档进入编辑模式:

文档编辑模式

现在,您可以通过单击要更改的项目并修改其值来更改此文档。

有关在 Compass 中更新文档的详细说明,请参阅 Compass 文档或按照以下示例进行操作。

对更改满意后,点击 Update 保存更新后的文档。

单击 Cancel 以还原对文档所做的任何修改,并退出编辑模式。

要更新文档,MongoDB 提供 $set更新操作符来修改字段值。

要使用更新操作符,请向更新方法传递以下形式的更新文档:

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

某些更新操作符(例如 $set)会在字段不存在的情况下创建字段。有关详细信息,请参阅相应的更新操作符参考信息。

要更新文档,MongoDB 提供 $set更新操作符来修改字段值。

某些更新操作符(例如 $set)会在字段不存在的情况下创建字段。有关详细信息,请参阅相应的更新操作符参考信息。

要更新文档,MongoDB 提供 $set更新操作符来修改字段值。

驱动程序提供了 com.mongodb.client.model.Updates 类来促进更新文档的创建。例如:

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

有关更新辅助程序的列表,请参阅 com.mongodb.client.model.Updates

某些更新操作符(例如 $set)会在字段不存在的情况下创建字段。有关详细信息,请参阅相应的更新操作符参考信息。

要更新文档,MongoDB 提供 $set更新操作符来修改字段值。

驱动程序提供了 com.mongodb.client.model.Updates 类来促进更新文档的创建。例如:

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

有关更新辅助程序的列表,请参阅 com.mongodb.client.model.Updates

某些更新操作符(例如 $set)会在字段不存在的情况下创建字段。有关详细信息,请参阅相应的更新操作符参考信息。

要更新文档, MongoDB提供了更新操作符(例如$set来修改字段值。

驾驶员提供 com.mongodb。 客户端.model.Updates 类,以便于创建更新文档。以下代码显示了使用Updates构建器类中的方法的更新文档:

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

某些更新操作符(例如 $set)会在字段不存在的情况下创建字段。有关详细信息,请参阅相应的更新操作符参考信息。

要更新文档,MongoDB 提供 $set更新操作符来修改字段值。

要使用更新操作符,请向更新方法传递以下形式的更新文档:

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

某些更新操作符(例如 $set)会在字段不存在的情况下创建字段。有关详细信息,请参阅相应的更新操作符参考信息。

要更新文档,MongoDB 提供 $set更新操作符来修改字段值。

要使用更新操作符,请向更新方法传递以下形式的更新文档:

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

某些更新操作符(例如 $set)会在字段不存在的情况下创建字段。有关详细信息,请参阅相应的更新操作符参考信息。

要更新文档,MongoDB 提供 $set更新操作符来修改字段值。

要使用更新操作符,请向更新方法传递以下形式的更新文档:

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

某些更新操作符(例如 $set)会在字段不存在的情况下创建字段。有关详细信息,请参阅相应的更新操作符参考信息。

要更新文档,MongoDB 提供 $set更新操作符来修改字段值。

要使用更新操作符,请向更新方法传递以下形式的更新文档:

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

某些更新操作符(例如 $set)会在字段不存在的情况下创建字段。有关详细信息,请参阅相应的更新操作符参考信息。

要更新文档,MongoDB 提供 $set更新操作符来修改字段值。

要使用更新操作符,请向更新方法传递以下形式的更新文档:

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

某些更新操作符(例如 $set)会在字段不存在的情况下创建字段。有关详细信息,请参阅相应的更新操作符参考信息。

要更新文档,MongoDB 提供 $set更新操作符来修改字段值。

要使用更新操作符,请向更新方法传递以下形式的更新文档:

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

某些更新操作符(例如 $set)会在字段不存在的情况下创建字段。有关详细信息,请参阅相应的更新操作符参考信息。

要更新文档,MongoDB 提供 $set更新操作符来修改字段值。

要使用更新操作符,请向更新方法传递以下形式的更新文档:

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

某些更新操作符(例如 $set)会在字段不存在的情况下创建字段。有关详细信息,请参阅相应的更新操作符参考信息。

注意

MongoDB 可以接受聚合管道来指定要进行的修改,而不是更新文档。有关详细信息,请参阅方法参考页面。

以下示例使用 inventory 集合上的 db.collection.updateOne() 方法来更新 item 等于 "paper"第一个文档:

以下示例演示了如何使用 MongoDB Compass 修改 inventory 集合中的单个文档,其中 item: paper

注意

此示例使用Compass表格视图来修改文档。使用Compass列表视图的编辑进程遵循类似的方法。

有关 Compass 中表视图和列表视图之间区别的更多信息,请参阅Compass 文档。

以下示例使用 IMongoCollection.UpdateOne() 方法在 inventory 集合上更新第一个 item 等于 "paper" 的文档:

以下示例使用 Collection.UpdateOne 方法在 inventory 集合上更新第一个 item 等于 "paper" 的文档:

以下示例使用 com.mongodb.reactivestreams.client.MongoCollection.updateOneinventory 集合上更新 item 等于 "paper"第一个文档:

以下示例使用 com.mongodb.client.MongoCollection.updateOne 方法在 inventory 集合上更新 item 等于 "paper"第一个文档:

以下示例使用 MongoCollection.updateOne()方法(在inventory集合上更新item等于"paper"第一个文档):

以下示例使用 update_one 方法在 inventory 集合上更新 item 等于 "paper"第一个文档:

以下示例使用 Collection.updateOne()方法在 inventory 集合上更新第一个 item 等于 "paper" 的文档:

以下示例使用 update_one() 方法在 inventory 集合上更新第一个 item 等于 "paper" 的文档:

以下示例使用 updateOne() 方法来更新 inventory 集合中 item 等于 "paper"第一个文档:

以下示例使用 update_one 方法在 inventory 集合上更新 item 等于 "paper"第一个文档:

以下示例使用 update_one() 方法在 inventory 集合上更新 item 等于 "paper"第一个文档:

以下示例使用 updateOne() 方法在 inventory 集合上更新第一个 item 等于 "paper" 的文档:

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

更新操作:

  • 使用 $set 操作符将 size.uom 字段的值更新为 "cm",并将 status 字段的值更新为 "P"

  • 使用 $currentDate 操作符将 lastModified 字段的值更新为当前日期。如果 lastModified 字段不存在,则 $currentDate 将创建该字段。有关详细信息,请参阅 $currentDate

请按如下方式修改目标文档:

  • status 字段从 D 更改为 P

  • size.uom 字段从 in 更改为 cm

  • 添加一个名为 lastModified 的新字段,其值将是今天的日期。

  1. 单击顶部导航中的 Table 按钮,访问表格视图:

    Access Table 视图
  2. 使用 Compass 查询栏来定位目标文档。

    将以下过滤器文档复制到查询栏中,然后单击 Find

    { item: "paper" }
    查找纸质文档
  3. 将鼠标悬停在 status 字段上,然后单击文档右侧出现的铅笔图标以进入编辑模式:

    单击编辑按钮
  4. 将该字段的值更改为 "P"

  5. 单击字段下方的 Update 按钮以保存您的更改。

  6. 将鼠标悬停在 size 字段上,然后单击字段右侧显示的向外箭头。这将打开一个新选项卡,显示 size 对象中的字段:

    展开尺寸对象
  7. 使用步骤 3-5 中概述的相同过程来编辑 status 字段,将 size.uom 字段的值更改为 "cm"

  8. 单击表格上方标有 inventory的最左侧标签页,返回原始表格视图,该视图显示顶级文档:

    点击库存标签页
  9. 将鼠标悬停在 status 字段上,然后单击文档右侧出现的铅笔图标以重新进入编辑模式。

  10. 单击 status 字段内,然后单击编辑菜单中显示的 plus button 图标。

    单击加号按钮下方显示的 Add Field After status 按钮:

    在状态后添加字段
  11. 添加一个名为 lastModified 的新字段,其值将是今天的日期。将字段类型设置为 Date:

    提交更新
  12. 单击字段下方的 Update 按钮以保存您的更改。

    注意

    由于 MongoDB Compass 不支持 $currentDate 或任何其他字段更新操作符,您必须在 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);

更新操作:

  • 使用 $set 操作符将 size.uom 字段的值更新为 "cm",并将 status 字段的值更新为 "P"

  • 使用 $currentDate 操作符将 lastModified 字段的值更新为当前日期。如果 lastModified 字段不存在,则 $currentDate 将创建该字段。有关详细信息,请参阅 $currentDate

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

更新操作:

  • 使用 $set 操作符将 size.uom 字段的值更新为 "cm",并将 status 字段的值更新为 "P"

  • 使用 $currentDate 操作符将 lastModified 字段的值更新为当前日期。如果 lastModified 字段不存在,则 $currentDate 将创建该字段。有关详细信息,请参阅 $currentDate

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

更新操作:

  • 使用 $set 操作符将 size.uom 字段的值更新为 "cm",并将 status 字段的值更新为 "P"

  • 使用 $currentDate 操作符将 lastModified 字段的值更新为当前日期。如果 lastModified 字段不存在,则 $currentDate 将创建该字段。有关详细信息,请参阅 $currentDate

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

更新操作:

  • 使用 $set 操作符将 size.uom 字段的值更新为 "cm",并将 status 字段的值更新为 "P"

  • 使用 $currentDate 操作符将 lastModified 字段的值更新为当前日期。如果 lastModified 字段不存在,则 $currentDate 将创建该字段。有关详细信息,请参阅 $currentDate

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

更新操作:

  • 使用 $set 操作符将 size.uom 字段的值更新为 "cm",并将 status 字段的值更新为 "P"

  • 使用 $currentDate 操作符将 lastModified 字段的值更新为当前日期。如果 lastModified 字段不存在,则 $currentDate 将创建该字段。有关详细信息,请参阅 $currentDate

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

更新操作:

  • 使用 $set 操作符将 size.uom 字段的值更新为 "cm",并将 status 字段的值更新为 "P"

  • 使用 $currentDate 操作符将 lastModified 字段的值更新为当前日期。如果 lastModified 字段不存在,则 $currentDate 将创建该字段。有关详细信息,请参阅 $currentDate

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

更新操作:

  • 使用 $set 操作符将 size.uom 字段的值更新为 "cm",并将 status 字段的值更新为 "P"

  • 使用 $currentDate 操作符将 lastModified 字段的值更新为当前日期。如果 lastModified 字段不存在,则 $currentDate 将创建该字段。有关详细信息,请参阅 $currentDate

# For boolean values, use boolean.pm for 'true' and 'false'
$db->coll("inventory")->update_one(
{ item => "paper" },
{
'$set' => { "size.uom" => "cm", status => "P" },
'$currentDate' => { lastModified => true }
}
);

更新操作:

  • 使用 $set 操作符将 size.uom 字段的值更新为 "cm",并将 status 字段的值更新为 "P"

  • 使用 $currentDate 操作符将 lastModified 字段的值更新为当前日期。如果 lastModified 字段不存在,则 $currentDate 将创建该字段。有关详细信息,请参阅 $currentDate

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

更新操作:

  • 使用 $set 操作符将 size.uom 字段的值更新为 "cm",并将 status 字段的值更新为 "P"

  • 使用 $currentDate 操作符将 lastModified 字段的值更新为当前日期。如果 lastModified 字段不存在,则 $currentDate 将创建该字段。有关详细信息,请参阅 $currentDate

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

更新操作:

  • 使用 $set 操作符将 size.uom 字段的值更新为 "cm",并将 status 字段的值更新为 "P"

  • 使用 $currentDate 操作符将 lastModified 字段的值更新为当前日期。如果 lastModified 字段不存在,则 $currentDate 将创建该字段。有关详细信息,请参阅 $currentDate

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

更新操作:

  • 使用 $set 操作符将 size.uom 字段的值更新为 "cm",并将 status 字段的值更新为 "P"

  • 使用 $currentDate 操作符将 lastModified 字段的值更新为当前日期。如果 lastModified 字段不存在,则 $currentDate 将创建该字段。有关详细信息,请参阅 $currentDate

如下示例使用 inventory 集合上的 db.collection.updateMany() 方法更新 qty 小于 50 的所有文档:

在 MongoDB Compass 中,一次只能更新一个文档。要更新多个文档,请从 mongosh 或 MongoDB 驱动程序连接到 MongoDB 部署,并按照本节中的示例选择您的首选方法。

以下示例使用 inventory 集合上的 IMongoCollection.UpdateMany() 方法更新 qty 小于 50 的所有文档:

以下示例使用 inventory 集合上的 Collection.UpdateMany 方法更新 qty 小于 50 的所有文档:

下面的示例在 inventory 集合上使用 com.mongodb.reactivestreams.client.MongoCollection.updateMany 方法更新了 qty 小于 50 的所有文档:

以下示例使用 inventory 集合上的 com.mongodb.client.MongoCollection.updateMany 方法更新 qty 小于 50 的所有文档:

以下示例使用 MongoCollection.updateMany()方法(位于inventory集合上)以更新qty小于50的所有文档:

以下示例使用 update_many 方法在 inventory 集合上更新 qty 小于 50 的所有文档:

如下示例使用 Collection.updateMany()方法(位于 inventory 集合上)更新 qty 小于 50 的所有文档:

以下示例在 inventory 集合上使用 update_many () 方法来更新 qty 小于 50 的所有文档:

下面的示例使用 updateMany() 方法在 inventory 集合上更新 qty 小于 50 的所有文档:

以下示例使用 update_many 方法在 inventory 集合上更新 qty 小于 50 的所有文档:

下面的示例使用 inventory 集合上的 update_many() 方法更新 qty 小于 50 的所有文档:

以下示例使用 updateMany() 方法在 inventory 集合上更新 qty 小于 50 的所有文档:

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

更新操作:

  • 使用 $set 操作符将 size.uom 字段的值更新为 "in",并将 status 字段的值更新为 "P"

  • 使用 $currentDate 操作符将 lastModified 字段的值更新为当前日期。如果 lastModified 字段不存在,则 $currentDate 将创建该字段。有关详细信息,请参阅 $currentDate

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

更新操作:

  • 使用 $set 操作符将 size.uom 字段的值更新为 "in",并将 status 字段的值更新为 "P"

  • 使用 $currentDate 操作符将 lastModified 字段的值更新为当前日期。如果 lastModified 字段不存在,则 $currentDate 将创建该字段。有关详细信息,请参阅 $currentDate

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

更新操作:

  • 使用 $set 操作符将 size.uom 字段的值更新为 "in",并将 status 字段的值更新为 "P"

  • 使用 $currentDate 操作符将 lastModified 字段的值更新为当前日期。如果 lastModified 字段不存在,则 $currentDate 将创建该字段。有关详细信息,请参阅 $currentDate

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

更新操作:

  • 使用 $set 操作符将 size.uom 字段的值更新为 "in",并将 status 字段的值更新为 "P"

  • 使用 $currentDate 操作符将 lastModified 字段的值更新为当前日期。如果 lastModified 字段不存在,则 $currentDate 将创建该字段。有关详细信息,请参阅 $currentDate

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

更新操作:

  • 使用 $set 操作符将 size.uom 字段的值更新为 "in",并将 status 字段的值更新为 "P"

  • 使用 $currentDate 操作符将 lastModified 字段的值更新为当前日期。如果 lastModified 字段不存在,则 $currentDate 将创建该字段。有关详细信息,请参阅 $currentDate

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

更新操作:

  • 使用 $set 操作符将 size.uom 字段的值更新为 "in",并将 status 字段的值更新为 "P"

  • 使用 $currentDate 操作符将 lastModified 字段的值更新为当前日期。如果 lastModified 字段不存在,则 $currentDate 将创建该字段。有关详细信息,请参阅 $currentDate

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

更新操作:

  • 使用 $set 操作符将 size.uom 字段的值更新为 "in",并将 status 字段的值更新为 "P"

  • 使用 $currentDate 操作符将 lastModified 字段的值更新为当前日期。如果 lastModified 字段不存在,则 $currentDate 将创建该字段。有关详细信息,请参阅 $currentDate

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

更新操作:

  • 使用 $set 操作符将 size.uom 字段的值更新为 "in",并将 status 字段的值更新为 "P"

  • 使用 $currentDate 操作符将 lastModified 字段的值更新为当前日期。如果 lastModified 字段不存在,则 $currentDate 将创建该字段。有关详细信息,请参阅 $currentDate

# For boolean values, use boolean.pm for 'true' and 'false'
$db->coll("inventory")->update_many(
{ qty => { '$lt' => 50 } },
{
'$set' => { "size.uom" => "in", status => "P" },
'$currentDate' => { lastModified => true }
}
);

更新操作:

  • 使用 $set 操作符将 size.uom 字段的值更新为 "in",并将 status 字段的值更新为 "P"

  • 使用 $currentDate 操作符将 lastModified 字段的值更新为当前日期。如果 lastModified 字段不存在,则 $currentDate 将创建该字段。有关详细信息,请参阅 $currentDate

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

更新操作:

  • 使用 $set 操作符将 size.uom 字段的值更新为 "in",并将 status 字段的值更新为 "P"

  • 使用 $currentDate 操作符将 lastModified 字段的值更新为当前日期。如果 lastModified 字段不存在,则 $currentDate 将创建该字段。有关详细信息,请参阅 $currentDate

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

更新操作:

  • 使用 $set 操作符将 size.uom 字段的值更新为 "in",并将 status 字段的值更新为 "P"

  • 使用 $currentDate 操作符将 lastModified 字段的值更新为当前日期。如果 lastModified 字段不存在,则 $currentDate 将创建该字段。有关详细信息,请参阅 $currentDate

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

更新操作:

  • 使用 $set 操作符将 size.uom 字段的值更新为 "in",并将 status 字段的值更新为 "P"

  • 使用 $currentDate 操作符将 lastModified 字段的值更新为当前日期。如果 lastModified 字段不存在,则 $currentDate 将创建该字段。有关详细信息,请参阅 $currentDate

要替换除 _id 字段之外的文档的所有内容,请将全新文档作为第二个参数传递给 db.collection.replaceOne()

替换文档时,替换文档必须仅包含字段/值对。替换文档不能包含更新操作符表达式。

替换文档可以具有与原始文档不同的字段。在替换文档中,您可以省略 _id 字段,因为 _id 字段是不可变的。但是,如果确实包括 _id 字段,则它的值必须与当前值相同。

如下示例将替换 inventory 集合中的第一个文档,其中的 item: "paper"

您无法替换 MongoDB Compass 中的文档。要替换文档,请从 mongosh 或 MongoDB 驱动程序连接到 MongoDB 部署,并按照本部分中的示例选择您的首选方法。

要替换除 _id 字段之外的文档的所有内容,请将全新文档作为第二个参数传递给 IMongoCollection.ReplaceOne()

替换文档时,替换文档必须仅包含字段/值对。替换文档不能包含更新操作符表达式。

替换文档可以具有与原始文档不同的字段。在替换文档中,您可以省略 _id 字段,因为 _id 字段是不可变的。但是,如果确实包括 _id 字段,则它的值必须与当前值相同。

如下示例将替换 inventory 集合中的第一个文档,其中的 item: "paper"

要替换除 _id 字段之外的文档的所有内容,请将全新文档作为第二个参数传递给 Collection.ReplaceOne

替换文档时,替换文档必须仅包含字段/值对。替换文档不能包含更新操作符表达式。

替换文档可以具有与原始文档不同的字段。在替换文档中,您可以省略 _id 字段,因为 _id 字段是不可变的。但是,如果确实包括 _id 字段,则它的值必须与当前值相同。

如下示例将替换 inventory 集合中的第一个文档,其中的 item: "paper"

要替换除 _id 字段之外的文档的所有内容,请将全新文档作为第二个参数传递给 com.mongodb.reactivestreams.client.MongoCollection.replaceOne

替换文档时,替换文档必须仅包含字段/值对。替换文档不能包含更新操作符表达式。

替换文档可以具有与原始文档不同的字段。在替换文档中,您可以省略 _id 字段,因为 _id 字段是不可变的。但是,如果确实包括 _id 字段,则它的值必须与当前值相同。

如下示例将替换 inventory 集合中的第一个文档,其中的 item: "paper"

要替换除 _id 字段之外的文档的所有内容,请将全新文档作为第二个参数传递给 com.mongodb.client.MongoCollection.replaceOne

替换文档时,替换文档必须仅包含字段/值对。替换文档不能包含更新操作符表达式。

替换文档可以具有与原始文档不同的字段。在替换文档中,您可以省略 _id 字段,因为 _id 字段是不可变的。但是,如果确实包括 _id 字段,则它的值必须与当前值相同。

如下示例将替换 inventory 集合中的第一个文档,其中的 item: "paper"

要替换除_id 字段之外的文档的全部内容,请将全新文档作为第二个参数传递给 MongoCollection.replaceOne()方法。

替换文档时,替换文档必须仅包含字段/值对。替换文档不能包含更新操作符表达式。

替换文档可以具有与原始文档不同的字段。在替换文档中,您可以省略 _id 字段,因为 _id 字段是不可变的。但是,如果确实包括 _id 字段,则它的值必须与当前值相同。

如下示例将替换 inventory 集合中的第一个文档,其中的 item: "paper"

要替换除 _id 字段之外的文档的所有内容,请将全新文档作为第二个参数传递给 replace_one

替换文档时,替换文档必须仅包含字段/值对。替换文档不能包含更新操作符表达式。

替换文档可以具有与原始文档不同的字段。在替换文档中,您可以省略 _id 字段,因为 _id 字段是不可变的。但是,如果确实包括 _id 字段,则它的值必须与当前值相同。

如下示例将替换 inventory 集合中的第一个文档,其中的 item: "paper"

要替换除 _id 字段之外的文档的所有内容,请将全新文档作为第二个参数传递给 Collection.replaceOne()

替换文档时,替换文档必须仅包含字段/值对。替换文档不能包含更新操作符表达式。

替换文档可以具有与原始文档不同的字段。在替换文档中,您可以省略 _id 字段,因为 _id 字段是不可变的。但是,如果确实包括 _id 字段,则它的值必须与当前值相同。

如下示例将替换 inventory 集合中的第一个文档,其中的 item: "paper"

要替换文档中除 _id 字段之外的全部内容,请将全新文档作为第二个参数传递给 replace_one()。

替换文档时,替换文档必须仅包含字段/值对。替换文档不能包含更新操作符表达式。

替换文档可以具有与原始文档不同的字段。在替换文档中,您可以省略 _id 字段,因为 _id 字段是不可变的。但是,如果确实包括 _id 字段,则它的值必须与当前值相同。

如下示例将替换 inventory 集合中的第一个文档,其中的 item: "paper"

要替换除 _id 字段之外的文档的所有内容,请将全新文档作为第二个参数传递给 replaceOne()

替换文档时,替换文档必须仅包含字段/值对。替换文档不能包含更新操作符表达式。

替换文档可以具有与原始文档不同的字段。在替换文档中,您可以省略 _id 字段,因为 _id 字段是不可变的。但是,如果确实包括 _id 字段,则它的值必须与当前值相同。

如下示例将替换 inventory 集合中的第一个文档,其中的 item: "paper"

要替换除 _id 字段之外的文档的所有内容,请将全新文档作为第二个参数传递给 replace_one

替换文档时,替换文档必须仅包含字段/值对。替换文档不能包含更新操作符表达式。

替换文档可以具有与原始文档不同的字段。在替换文档中,您可以省略 _id 字段,因为 _id 字段是不可变的。但是,如果确实包括 _id 字段,则它的值必须与当前值相同。

如下示例将替换 inventory 集合中的第一个文档,其中的 item: "paper"

要替换除 _id 字段之外的文档的所有内容,请将全新文档作为第二个参数传递给 replace_one().

替换文档时,替换文档必须仅包含字段/值对。替换文档不能包含更新操作符表达式。

替换文档可以具有与原始文档不同的字段。在替换文档中,您可以省略 _id 字段,因为 _id 字段是不可变的。但是,如果确实包括 _id 字段,则它的值必须与当前值相同。

如下示例将替换 inventory 集合中的第一个文档,其中的 item: "paper"

要替换除 _id字 段外的整个文档内容,请将一个全新的文档作为第二个参数传递给 replaceOne()

替换文档时,替换文档必须仅包含字段/值对。替换文档不能包含更新操作符表达式。

替换文档可以具有与原始文档不同的字段。在替换文档中,您可以省略 _id 字段,因为 _id 字段是不可变的。但是,如果确实包括 _id 字段,则它的值必须与当前值相同。

如下示例将替换 inventory 集合中的第一个文档,其中的 item: "paper"

db.inventory.replaceOne(
{ item: "paper" },
{ item: "paper", instock: [ { warehouse: "A", qty: 60 }, { warehouse: "B", qty: 40 } ] }
)
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;
}

此外,请务必根据需要调用以下方法来清理所有打开的资源:

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 }
]
}
);
$db->coll("inventory")->replace_one(
{ 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()

注意

在 MongoDB Atlas 用户界面中,一次只能更新一个文档。要更新多个文档或替换整个文档,请从 mongosh 或 MongoDB 驱动程序连接到您的 Atlas 部署,并按照本页面上的示例选择您的首选方法。

本节中的示例使用的是用品公司示例数据集。要了解如何将示例数据集加载到您的 MongoDB Atlas 部署中,请参阅加载示例数据。

要更新除 MongoDB Atlas 中的文档,请按以下步骤操作:

1
  1. 如果尚未显示,请从导航栏上的 Organizations 菜单中选择包含所需项目的组织。

  2. 如果尚未显示,请从导航栏的 Projects 菜单中选择您的项目。

  3. 如果尚未显示,请单击侧边栏中的Clusters

    会显示集群页面。

2
  1. 对于包含样本数据的集群,单击Browse Collections

  2. 在左侧导航窗格中,选择 sample_supplies 数据库。

  3. 选择 sales 集合。

3

您可以在 Filter 字段中指定查询筛选器文档。查询筛选器文档使用查询运算符来指定搜索条件。

将以下查询筛选器文档复制到 Filter 搜索栏,然后单击 Apply

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

此查询过滤器返回 sample_supplies.sales 集合中 saleDate 等于 UTC 时间 2016 年 1 月 1 日和 2 日之间的任何时间(包含这两个时间)的所有文档。

4

要编辑查询结果中显示的文档,请将鼠标悬停在此文档上,然后单击“铅笔”图标。在文档编辑器中,您可以:

  • 添加新字段。

  • 删除现有字段。

  • 编辑字段的名称、值或类型。

  • 还原特定更改。

有关详细说明,请参阅创建、查看、更新和删除文档。

5

要确认并保存更改,请单击 Update(更新)按钮。

MongoDB 中的所有写入操作在单个文档级别上都是原子性的。有关 MongoDB 和原子性的更多信息,请参阅原子性和事务。

设置后,您将无法更新 _id 字段的值,也无法使用具有其他 _id 字段值的替换文档替换现有文档。

对于写入操作,MongoDB 会保留文档字段的顺序,但以下情况除外

  • _id 字段始终是文档中的第一个字段。

  • 包含字段名称 renaming 的更新可能会导致文档中的字段重新排序。

如果 updateOne()updateMany()replaceOne() 包含 upsert : true而且没有任何文档符合指定的筛选条件,此操作将创建并插入一个新文档。如果存在匹配的文档,则该操作会修改或替换匹配的一个或多个文档。

有关创建的新文档的详细信息,请参阅方法的单独参考页面。

更新或插入选项在 MongoDB Compass 中不可用。

如果 UpdateOne()UpdateMany()ReplaceOne() 包括一个 UpdateOptions 参数实例,IsUpsert 选项设置为 true 无文档匹配指定的过滤器,则该操作创建并插入一个新文档。如果存在匹配的文档,则该操作会修改或替换匹配的一个或多个文档。

有关创建的新文档的详细信息,请参阅方法的单独参考页面。

如果 Collection.UpdateOne 包含设置为 true 的插入或更新选项 ,且没有与指定过滤器匹配的文档,则该操作会创建一个新文档并将其插入。如果存在匹配的文档,则该操作会修改或替换匹配的一个或多个文档。

有关创建的新文档的详细信息,请参阅方法的单独参考页面。

如果更新和替换方法包含指定 UpdateOptions.upsert(true)UpdateOptions 参数,并且没有与指定过滤器匹配的文档,则操作会创建并插入一个新文档。如果存在匹配的文档,则该操作会修改或替换匹配的一个或多个文档。

有关创建的新文档的详细信息,请参阅方法的单独参考页面。

如果更新和替换方法包含指定 com.mongodb.client.model.UpdateOptions.upsert(true)com.mongodb.client.model.UpdateOptions 参数并且没有与指定过滤器匹配的文档,则该操作将创建一个新文档并将其插入。如果存在匹配的文档,则该操作会修改或替换匹配的一个或多个文档。

有关创建的新文档的详细信息,请参阅方法的单独参考页面。

如果更新和替换方法包含 com.mongodb. 客户端.model.UpdateOptions 参数指定upsert(true) 并且 没有文档与指定的过滤匹配,则该操作将创建一个新文档并将其插入。如果存在匹配的文档,则该操作会修改或替换匹配的一个或多个文档。

有关创建的新文档的详细信息,请参阅方法的单独参考页面。

如果 update_oneupdate_manyreplace_one 包含 upsert : true没有与指定过滤器匹配的文档,则该操作会创建一个新文档并将其插入。如果存在匹配的文档,则该操作会修改或替换匹配的一个或多个文档。

有关创建的新文档的详细信息,请参阅方法的单独参考页面。

如果 updateOne()updateMany()replaceOne()options 参数文档中包含 upsert : true并且没有与指定过滤器匹配的文档,则该操作将创建一个新文档并将其插入。如果存在匹配的文档,则该操作会修改或替换匹配的一个或多个文档。

有关创建的新文档的详细信息,请参阅方法的单独参考页面。

如果 update_one()update_many()replace_one() 包含 upsert => true没有与指定过滤器匹配的文档,则该操作将创建一个新文档并将其插入。如果存在匹配的文档,则该操作会修改或替换匹配的一个或多个文档。

有关创建的新文档的详细信息,请参阅方法的单独参考页面。

如果 updateOne()updateMany()replaceOne() 包含 upsert => true而且没有任何文档符合指定的过滤条件,此操作将创建并插入一个新文档。如果存在匹配的文档,则此操作会修改或替换匹配的一个或多个文档。

有关创建的新文档的详细信息,请参阅方法的单独参考页面。

如果 update_oneupdate_manyreplace_one 包含 upsert : true没有与指定过滤器匹配的文档,则该操作会创建一个新文档并将其插入。如果存在匹配的文档,则该操作会修改或替换匹配的一个或多个文档。

有关创建的新文档的详细信息,请参阅方法的单独参考页面。

如果 update_one() update_many() replace_one() 包含 upsert => true , 且没有文档符合指定的过滤器,则该操作会创建一个新文档并插入它。如果存在匹配的文档,则该操作会修改或替换匹配的一个或多个文档。

有关创建的新文档的详细信息,请参阅方法的单独参考页面。

如果 updateOne()updateMany()replaceOne() 包含 upsert => true没有与指定过滤器匹配的文档,则该操作将创建一个新文档并将其插入。如果存在匹配的文档,则该操作会修改或替换匹配的一个或多个文档。

有关创建的新文档的详细信息,请参阅方法的单独参考页面。

对于写关注,您可以指定 MongoDB 请求的写操作确认级别。有关详细信息,请参阅写关注

提示

另请参阅:

提示

另请参阅:

后退

在 mongosh 中迭代游标