更新文档

本页内容

在集合中更新文档

使用 MongoDB Atlas 更新文档
行为

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

您编程语言的驱动程序。
的MongoDB Atlas UI. 有关更多信息，请参阅使用 MongoDB Atlas 更新文档。
MongoDB Compass.

➤使用右上角的 选择您的语言 下拉菜单设置以下示例的语言。

本页面使用以下 mongosh 方法

本页面的示例使用 inventory 集合。连接到您的 MongoDB 实例中的测试数据库然后创建 inventory 集合

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

本页面的示例使用 inventory 集合。使用以下文档填充 inventory 集合

本页面使用以下 MongoDB C Driver 方法

本页面的示例使用 inventory 集合。连接到您的 MongoDB 实例中的测试数据库然后创建 inventory 集合

本页面使用以下 MongoDB C# Driver 方法

本页面的示例使用 inventory 集合。连接到您的 MongoDB 实例中的测试数据库然后创建 inventory 集合

本页面使用以下 MongoDB Go Driver 函数

本页面的示例使用 inventory 集合。连接到您的 MongoDB 实例中的测试数据库然后创建 inventory 集合

本页面使用以下 Java Reactive Streams Driver 方法

本页面的示例使用 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文档或遵循下面的示例。

对更改满意后，单击更新以保存更新的文档。

单击取消以撤销对文档所做的任何修改并退出编辑模式。

要更新文档，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 可以接受一个聚合管道来指定要进行的修改，而不是更新文档。有关详细信息，请参阅方法参考页面。

更新单个文档

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

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

注意

此示例使用 Compass Table View 来修改文档。使用 Compass List View 的编辑过程采用类似的方法。

有关 Compass 中 Table View 和 List View 之间差异的更多信息，请参阅 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" 的文档进行更新

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

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

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

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

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

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

点击顶部导航中的表格按钮，以访问表格视图：
使用 Compass 的查询栏定位目标文档。
将以下筛选文档复制到查询栏，并点击查找
```
{ item: "paper" }
```
将鼠标悬停在 status 字段上，并点击文档右侧出现的铅笔图标以进入编辑模式
将该字段的值更改为 "P"。
点击字段下方的更新按钮以保存您的更改。
将鼠标悬停在 size 字段上，并点击字段右侧出现的向外指的箭头。这将在新标签页中显示 size 对象内的字段
使用与步骤 3-5 中编辑 status 字段相同的步骤，将 size.uom 字段的值更改为 "cm"。
点击表格上方标有 inventory 的最左侧标签，以返回原始的表格视图，该视图显示顶层文档
将鼠标悬停在 status 字段上，并点击文档右侧出现的铅笔图标以重新进入编辑模式。
在 status 字段内部点击，并点击编辑菜单中出现的加号按钮图标。
点击加号按钮下方的在 status 后添加字段按钮
添加一个名为 lastModified 的新字段，其值为今天的日期。将字段类型设置为 日期
点击字段下方的更新按钮以保存您的更改。
注意
因为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。

更新多个文档

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

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

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

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

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

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

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

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

以下示例使用inventory集合中的Collection.updateMany()方法，更新所有qty小于50的文档

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

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

以下示例使用 update_many 方法对 inventory 集合中所有 qty 小于 50 的文档进行更新

以下示例使用 update_many() 方法对 inventory 集合中所有 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 UI中，您一次只能更新一个文档。要更新多个文档或替换整个文档，请从mongosh或MongoDB驱动连接到您的Atlas部署，并按照本页面上的示例进行操作。

本节中的示例使用了sample supplies数据集。有关如何将示例数据集加载到您的MongoDB Atlas部署中的信息，请参阅加载示例数据。

要在MongoDB Atlas中更新文档，请按照以下步骤操作

在MongoDB Atlas界面中，前往您项目的集群页面。

如果尚未显示，请从导航栏的组织菜单中选择包含您所需项目的组织。。
如果尚未显示，请从导航栏中的项目菜单中选择您的项目。
。
点击侧边栏中的集群。

页面显示集群。

导航到集合。
对于包含样本数据的集群，点击浏览集合。
在左侧导航窗格中，选择sample_supplies数据库。

选择`sales`集合。

指定一个查询过滤器文档。

您可以在过滤器字段中指定一个查询过滤器文档。查询过滤器文档使用查询运算符来指定搜索条件。

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

此查询过滤器返回所有在 sample_supplies.sales 集合中，并且 saleDate 在或介于2016年1月1日至2日UTC时间之间的文档。

编辑文档。

要编辑查询结果中显示的文档，将鼠标悬停在文档上并单击铅笔图标。在文档编辑器中，您可以

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

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

保存您的更改。

要确认并保存您的更改，请单击更新按钮。

行为

原子性

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

`_id` 字段

一旦设置，您就不能更新 _id 字段的值，也不能用具有不同 _id 字段值的替换文档替换现有文档。

字段顺序

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

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

Upsert 选项

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

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

通过以下方式不可用 upsert 选项：MongoDB Compass.

If UpdateOne(), UpdateMany(), or ReplaceOne() includes an UpdateOptions argument instance with the IsUpsert option set to true and no documents match the specified filter, then the operation creates a new document and inserts it. If there are matching documents, then the operation modifies or replaces the matching document or documents.

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

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

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

如果更新和替换方法包含指定 UpdateOptions 参数，并且没有文档匹配指定的过滤器，那么该操作将创建一个新的文档并将其插入。如果有匹配的文档，则操作将修改或替换匹配的文档或文档。

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

如果更新和替换方法包含指定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 并且没有文档匹配指定的过滤器，则操作会创建一个新的文档并将其插入。如果存在匹配的文档，则操作会修改或替换匹配的文档或文档集。

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

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

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

如果updateOne()、updateMany()或replaceOne()中包含upsert => true并且没有文档匹配指定的过滤器，那么操作将创建一个新的文档并将其插入。如果有匹配的文档，则操作将修改或替换匹配的文档或文档。

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

编写确认

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

在集合中更新文档

注意

更新单个文档

注意

注意

更新多个文档

替换文档

使用MongoDB Atlas更新文档

注意

在MongoDB Atlas界面中，前往您项目的集群页面。

页面显示集群。

选择sales集合。

编辑文档。

保存您的更改。

行为

原子性

_id 字段

字段顺序

Upsert 选项

编写确认

提示

另请参阅

提示

另请参阅

提示

另请参阅

提示

另请参阅

提示

另请参阅

提示

另请参阅

提示

另请参阅

提示

另请参阅

提示

另请参阅

提示

另请参阅

提示

另请参阅

提示

另请参阅

提示

另请参阅

提示

另请参阅

选择`sales`集合。

`_id` 字段