Update Documents

在此页面上

更新集合中的文档

使用 MongoDB Atlas 更新文档
行为

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

您的编程语言的驱动程序。
MongoDB Atlas 用户界面。要了解更多信息，请参阅使用 MongoDB Atlas 更新文档。
MongoDB Compass。

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

此页面使用以下 mongosh方法：

此页面上的示例使用的是 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.client.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 修改单个文档，其中item: paper位于inventorycollection中：

注意

本例使用 Compass 表格视图修改文档。使用 Compass 列表视图的编辑过程遵循非常相似的方法。

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

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

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

以下示例使用 com.mongodb.reactivestreams.client.MongoCollection.updateOne 在 inventory 集合上更新 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" 文档）：

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

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

以下示例使用inventory集合上的update_one()方法来更新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 的新字段，其值将是今天的日期。

单击顶部导航栏中的Table按钮以访问表视图：
使用 Compass查询栏查找目标文档。
将以下筛选器文档复制到查询栏中，然后单击Find ：
```
{ item: "paper" }
```
将鼠标悬停在status字段上，然后单击文档右侧显示的铅笔图标，进入编辑模式：
将该字段的值更改为 "P"。
单击字段下方的Update按钮，保存更改。
将鼠标悬停在size字段上，然后单击该字段右侧显示的向外箭头。这将打开一个新标签页，显示size对象中的字段：
使用步骤 3-5 中概述的相同过程来编辑 status 字段，将 size.uom 字段的值更改为 "cm"。
单击表上方标有inventory的最左侧标签页可返回到原始表视图，该视图显示顶级文档：
将鼠标悬停在 status 字段上，然后单击文档右侧出现的铅笔图标以重新进入编辑模式。
单击status字段内部，然后单击编辑菜单中显示的plus button图标。
单击加号按钮下方显示的Add Field After status按钮：
添加一个名为lastModified的新字段，其值为今天的日期。将字段类型设置为Date ：
单击字段下方的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 的所有文档：

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

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

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

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

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

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

以下示例使用 update_many() 方法（位于inventory 集合上）以更新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()。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

如下示例将替换 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 更新文档

注意

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

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

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

在 MongoDB AtlasClusters 用户界面中，转到项目的页面。

如果尚未显示，请从导航栏的 Organizations 菜单中选择包含所需项目的组织。
如果尚未显示，请从导航栏的 Projects（项目）菜单中选择所需的项目。
如果 Clusters（数据库部署）页面尚未出现，请单击侧边栏中的 Database（数据库）。
此时会显示“集群”页面。

导航至集合。

对于包含样本数据的集群，单击Browse Collections 。
在左侧导航窗格中，选择 sample_supplies 数据库。
选择 sales 集合。

指定查询筛选文档。

您可以在 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 日之间的任何时间（包含这两个时间）的所有文档。

Edit a document.

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

添加新字段。
删除现有字段。
编辑字段的名称、值或类型。
还原特定更改。

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

保存更改。

要确认并保存更改，请单击 Update（更新）按钮。

行为

原子性(Atomicity)

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

`_id` 字段

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

字段排序

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

_id 字段始终是文档中的第一个字段。
包含字段名称 renaming 的更新可能会导致文档中的字段重新排序。

更新或插入（upsert）选项

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

写确认

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

Update Documents.leafygreen-ui-m0pgrr{-webkit-align-self:center;-ms-flex-item-align:center;align-self:center;padding:0 10px;visibility:hidden;}.leafygreen-ui-a30zj9{color:#889397;vertical-align:middle;margin-top:-2px;}.css-fmznk8{margin-top:-85px;position:absolute;padding-bottom:2px;}

更新集合中的文档

注意

更新单份文档

注意

注意

更新多个文档

替换文档

使用 MongoDB Atlas 更新文档

注意

在 MongoDB AtlasClusters 用户界面中，转到项目的 页面。

导航至集合。

指定查询筛选文档。

Edit a document.

保存更改。

行为

原子性(Atomicity)

_id 字段

字段排序

更新或插入（upsert）选项

写确认

提示

另请参阅：

提示

另请参阅：

提示

另请参阅：

提示

另请参阅：

提示

另请参阅：

提示

另请参阅：

提示

另请参阅：

提示

另请参阅：

提示

另请参阅：

提示

另请参阅：

提示

另请参阅：

提示

另请参阅：

提示

另请参阅：

提示

另请参阅：

Update Documents

在 MongoDB AtlasClusters 用户界面中，转到项目的页面。

`_id` 字段