Docs 菜单
Docs 主页
/
MongoDB Manual
/
增删改查操作

Update Documents

在此页面上

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

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

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

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

  • MongoDB Compass。

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

本页面使用以下 mongosh 方法：

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

db.inventory.insertMany( [
   { item: "canvas", qty: 100, size: { h: 28, w: 35.5, uom: "cm" }, status: "A" },
   { item: "journal", qty: 25, size: { h: 14, w: 21, uom: "cm" }, status: "A" },
   { item: "mat", qty: 85, size: { h: 27.9, w: 35.5, uom: "cm" }, status: "A" },
   { item: "mousepad", qty: 25, size: { h: 19, w: 22.85, uom: "cm" }, status: "P" },
   { item: "notebook", qty: 50, size: { h: 8.5, w: 11, uom: "in" }, status: "P" },
   { item: "paper", qty: 100, size: { h: 8.5, w: 11, uom: "in" }, status: "D" },
   { item: "planner", qty: 75, size: { h: 22.85, w: 30, uom: "cm" }, status: "D" },
   { item: "postcard", qty: 45, size: { h: 10, w: 15.25, uom: "cm" }, status: "A" },
   { item: "sketchbook", qty: 80, size: { h: 14, w: 21, uom: "cm" }, status: "A" },
   { item: "sketch pad", qty: 95, size: { h: 22.85, w: 30.5, uom: "cm" }, status: "A" }
] );
[
    { "item": "canvas", "qty": 100, "size": { "h": 28, "w": 35.5, "uom": "cm" }, "status": "A" },
    { "item": "journal", "qty": 25, "size": { "h": 14, "w": 21, "uom": "cm" }, "status": "A" },
    { "item": "mat", "qty": 85, "size": { "h": 27.9, "w": 35.5, "uom": "cm" }, "status": "A" },
    { "item": "mousepad", "qty": 25, "size": { "h": 19, "w": 22.85, "uom": "cm" }, "status": "P" },
    { "item": "notebook", "qty": 50, "size": { "h": 8.5, "w": 11, "uom": "in" }, "status": "P" },
    { "item": "paper", "qty": 100, "size": { "h": 8.5, "w": 11, "uom": "in" }, "status": "D" },
    { "item": "planner", "qty": 75, "size": { "h": 22.85, "w": 30, "uom": "cm" }, "status": "D" },
    { "item": "postcard", "qty": 45, "size": { "h": 10, "w": 15.25, "uom": "cm" }, "status": "A" },
    { "item": "sketchbook", "qty": 80, "size": { "h": 14, "w": 21, "uom": "cm" }, "status": "A" },
    { "item": "sketch pad", "qty": 95, "size": { "h": 22.85, "w": 30.5, "uom": "cm" }, "status": "A" }
]

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

mongoc_collection_t *collection;
mongoc_bulk_operation_t *bulk;
bson_t *doc;
bool r;
bson_error_t error;
bson_t reply;
collection = mongoc_database_get_collection (db, "inventory");
bulk = mongoc_collection_create_bulk_operation_with_opts (collection, NULL);
doc = BCON_NEW (
   "item", BCON_UTF8 ("canvas"),
   "qty", BCON_INT64 (100),
   "size", "{",
   "h", BCON_DOUBLE (28),
   "w", BCON_DOUBLE (35.5),
   "uom", BCON_UTF8 ("cm"),
   "}",
   "status", BCON_UTF8 ("A"));
r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error);
bson_destroy (doc);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}
doc = BCON_NEW (
   "item", BCON_UTF8 ("journal"),
   "qty", BCON_INT64 (25),
   "size", "{",
   "h", BCON_DOUBLE (14),
   "w", BCON_DOUBLE (21),
   "uom", BCON_UTF8 ("cm"),
   "}",
   "status", BCON_UTF8 ("A"));
r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error);
bson_destroy (doc);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}
doc = BCON_NEW (
   "item", BCON_UTF8 ("mat"),
   "qty", BCON_INT64 (85),
   "size", "{",
   "h", BCON_DOUBLE (27.9),
   "w", BCON_DOUBLE (35.5),
   "uom", BCON_UTF8 ("cm"),
   "}",
   "status", BCON_UTF8 ("A"));
r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error);
bson_destroy (doc);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}
doc = BCON_NEW (
   "item", BCON_UTF8 ("mousepad"),
   "qty", BCON_INT64 (25),
   "size", "{",
   "h", BCON_DOUBLE (19),
   "w", BCON_DOUBLE (22.85),
   "uom", BCON_UTF8 ("cm"),
   "}",
   "status", BCON_UTF8 ("P"));
r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error);
bson_destroy (doc);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}
doc = BCON_NEW (
   "item", BCON_UTF8 ("notebook"),
   "qty", BCON_INT64 (50),
   "size", "{",
   "h", BCON_DOUBLE (8.5),
   "w", BCON_DOUBLE (11),
   "uom", BCON_UTF8 ("in"),
   "}",
   "status", BCON_UTF8 ("P"));
r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error);
bson_destroy (doc);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}
doc = BCON_NEW (
   "item", BCON_UTF8 ("paper"),
   "qty", BCON_INT64 (100),
   "size", "{",
   "h", BCON_DOUBLE (8.5),
   "w", BCON_DOUBLE (11),
   "uom", BCON_UTF8 ("in"),
   "}",
   "status", BCON_UTF8 ("D"));
r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error);
bson_destroy (doc);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}
doc = BCON_NEW (
   "item", BCON_UTF8 ("planner"),
   "qty", BCON_INT64 (75),
   "size", "{",
   "h", BCON_DOUBLE (22.85),
   "w", BCON_DOUBLE (30),
   "uom", BCON_UTF8 ("cm"),
   "}",
   "status", BCON_UTF8 ("D"));
r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error);
bson_destroy (doc);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}
doc = BCON_NEW (
   "item", BCON_UTF8 ("postcard"),
   "qty", BCON_INT64 (45),
   "size", "{",
   "h", BCON_DOUBLE (10),
   "w", BCON_DOUBLE (15.25),
   "uom", BCON_UTF8 ("cm"),
   "}",
   "status", BCON_UTF8 ("A"));
r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error);
bson_destroy (doc);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}
doc = BCON_NEW (
   "item", BCON_UTF8 ("sketchbook"),
   "qty", BCON_INT64 (80),
   "size", "{",
   "h", BCON_DOUBLE (14),
   "w", BCON_DOUBLE (21),
   "uom", BCON_UTF8 ("cm"),
   "}",
   "status", BCON_UTF8 ("A"));
r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error);
bson_destroy (doc);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}
doc = BCON_NEW (
   "item", BCON_UTF8 ("sketch pad"),
   "qty", BCON_INT64 (95),
   "size", "{",
   "h", BCON_DOUBLE (22.85),
   "w", BCON_DOUBLE (30.5),
   "uom", BCON_UTF8 ("cm"),
   "}",
   "status", BCON_UTF8 ("A"));
r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error);
bson_destroy (doc);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}
/* "reply" is initialized on success or error */
r = (bool) mongoc_bulk_operation_execute (bulk, &reply, &error);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
}
var documents = new[]
{
    new BsonDocument
    {
        { "item", "canvas" },
        { "qty", 100 },
        { "size", new BsonDocument { { "h", 28 }, { "w", 35.5 }, { "uom", "cm" } } },
        { "status", "A" }
    },
    new BsonDocument
    {
        { "item", "journal" },
        { "qty", 25 },
        { "size", new BsonDocument { { "h", 14 }, { "w", 21 }, { "uom", "cm" } } },
        { "status", "A" }
    },
    new BsonDocument
    {
        { "item", "mat" },
        { "qty", 85 },
        { "size", new BsonDocument { { "h", 27.9 }, { "w", 35.5 }, { "uom", "cm" } } },
        { "status", "A" }
    },
    new BsonDocument
    {
        { "item", "mousepad" },
        { "qty", 25 },
        { "size", new BsonDocument { { "h", 19 }, { "w", 22.85 }, { "uom", "cm" } } },
        { "status", "P" }
    },
    new BsonDocument
    {
        { "item", "notebook" },
        { "qty", 50 },
        { "size", new BsonDocument { { "h", 8.5 }, { "w", 11 }, { "uom", "in" } } },
        { "status", "P" } },
    new BsonDocument
    {
        { "item", "paper" },
        { "qty", 100 },
        { "size", new BsonDocument { { "h", 8.5 }, { "w", 11 }, { "uom", "in" } } },
        { "status", "D" }
    },
    new BsonDocument
    {
        { "item", "planner" },
        { "qty", 75 },
        { "size", new BsonDocument { { "h", 22.85 }, { "w", 30 }, { "uom", "cm" } } },
        { "status", "D" }
    },
    new BsonDocument
    {
        { "item", "postcard" },
        { "qty", 45 },
        { "size", new BsonDocument { { "h", 10 }, { "w", 15.25 }, { "uom", "cm" } } },
        { "status", "A" }
    },
    new BsonDocument
    {
        { "item", "sketchbook" },
        { "qty", 80 },
        { "size", new BsonDocument { { "h", 14 }, { "w", 21 }, { "uom", "cm" } } },
        { "status", "A" }
    },
    new BsonDocument
    {
        { "item", "sketch pad" },
        { "qty", 95 },
        { "size", new BsonDocument { { "h", 22.85 }, { "w", 30.5 }, { "uom", "cm" } } }, { "status", "A" } },
};
collection.InsertMany(documents);
docs := []interface{}{
	bson.D{
		{"item", "canvas"},
		{"qty", 100},
		{"size", bson.D{
			{"h", 28},
			{"w", 35.5},
			{"uom", "cm"},
		}},
		{"status", "A"},
	},
	bson.D{
		{"item", "journal"},
		{"qty", 25},
		{"size", bson.D{
			{"h", 14},
			{"w", 21},
			{"uom", "cm"},
		}},
		{"status", "A"},
	},
	bson.D{
		{"item", "mat"},
		{"qty", 85},
		{"size", bson.D{
			{"h", 27.9},
			{"w", 35.5},
			{"uom", "cm"},
		}},
		{"status", "A"},
	},
	bson.D{
		{"item", "mousepad"},
		{"qty", 25},
		{"size", bson.D{
			{"h", 19},
			{"w", 22.85},
			{"uom", "in"},
		}},
		{"status", "P"},
	},
	bson.D{
		{"item", "notebook"},
		{"qty", 50},
		{"size", bson.D{
			{"h", 8.5},
			{"w", 11},
			{"uom", "in"},
		}},
		{"status", "P"},
	},
	bson.D{
		{"item", "paper"},
		{"qty", 100},
		{"size", bson.D{
			{"h", 8.5},
			{"w", 11},
			{"uom", "in"},
		}},
		{"status", "D"},
	},
	bson.D{
		{"item", "planner"},
		{"qty", 75},
		{"size", bson.D{
			{"h", 22.85},
			{"w", 30},
			{"uom", "cm"},
		}},
		{"status", "D"},
	},
	bson.D{
		{"item", "postcard"},
		{"qty", 45},
		{"size", bson.D{
			{"h", 10},
			{"w", 15.25},
			{"uom", "cm"},
		}},
		{"status", "A"},
	},
	bson.D{
		{"item", "sketchbook"},
		{"qty", 80},
		{"size", bson.D{
			{"h", 14},
			{"w", 21},
			{"uom", "cm"},
		}},
		{"status", "A"},
	},
	bson.D{
		{"item", "sketch pad"},
		{"qty", 95},
		{"size", bson.D{
			{"h", 22.85},
			{"w", 30.5},
			{"uom", "cm"},
		}},
		{"status", "A"},
	},
}
result, err := coll.InsertMany(context.TODO(), docs)
Publisher<Success> insertManyPublisher = collection.insertMany(asList(
        Document.parse("{ item: 'canvas', qty: 100, size: { h: 28, w: 35.5, uom: 'cm' }, status: 'A' }"),
        Document.parse("{ item: 'journal', qty: 25, size: { h: 14, w: 21, uom: 'cm' }, status: 'A' }"),
        Document.parse("{ item: 'mat', qty: 85, size: { h: 27.9, w: 35.5, uom: 'cm' }, status: 'A' }"),
        Document.parse("{ item: 'mousepad', qty: 25, size: { h: 19, w: 22.85, uom: 'cm' }, status: 'P' }"),
        Document.parse("{ item: 'notebook', qty: 50, size: { h: 8.5, w: 11, uom: 'in' }, status: 'P' }"),
        Document.parse("{ item: 'paper', qty: 100, size: { h: 8.5, w: 11, uom: 'in' }, status: 'D' }"),
        Document.parse("{ item: 'planner', qty: 75, size: { h: 22.85, w: 30, uom: 'cm' }, status: 'D' }"),
        Document.parse("{ item: 'postcard', qty: 45, size: { h: 10, w: 15.25, uom: 'cm' }, status: 'A' }"),
        Document.parse("{ item: 'sketchbook', qty: 80, size: { h: 14, w: 21, uom: 'cm' }, status: 'A' }"),
        Document.parse("{ item: 'sketch pad', qty: 95, size: { h: 22.85, w: 30.5, uom: 'cm' }, status: 'A' }")
));
collection.insertMany(asList(
        Document.parse("{ item: 'canvas', qty: 100, size: { h: 28, w: 35.5, uom: 'cm' }, status: 'A' }"),
        Document.parse("{ item: 'journal', qty: 25, size: { h: 14, w: 21, uom: 'cm' }, status: 'A' }"),
        Document.parse("{ item: 'mat', qty: 85, size: { h: 27.9, w: 35.5, uom: 'cm' }, status: 'A' }"),
        Document.parse("{ item: 'mousepad', qty: 25, size: { h: 19, w: 22.85, uom: 'cm' }, status: 'P' }"),
        Document.parse("{ item: 'notebook', qty: 50, size: { h: 8.5, w: 11, uom: 'in' }, status: 'P' }"),
        Document.parse("{ item: 'paper', qty: 100, size: { h: 8.5, w: 11, uom: 'in' }, status: 'D' }"),
        Document.parse("{ item: 'planner', qty: 75, size: { h: 22.85, w: 30, uom: 'cm' }, status: 'D' }"),
        Document.parse("{ item: 'postcard', qty: 45, size: { h: 10, w: 15.25, uom: 'cm' }, status: 'A' }"),
        Document.parse("{ item: 'sketchbook', qty: 80, size: { h: 14, w: 21, uom: 'cm' }, status: 'A' }"),
        Document.parse("{ item: 'sketch pad', qty: 95, size: { h: 22.85, w: 30.5, uom: 'cm' }, status: 'A' }")
));
collection.insertMany(
    listOf(
        Document("item", "canvas")
            .append("qty", 100)
            .append("size", Document("h", 28).append("w", 35.5).append("uom", "cm"))
            .append("status", "A"),
        Document("item", "journal")
            .append("qty", 25)
            .append("size", Document("h", 14).append("w", 21).append("uom", "cm"))
            .append("status", "A"),
        Document("item", "mat")
            .append("qty", 85)
            .append("size", Document("h", 27.9).append("w", 35.5).append("uom", "cm"))
            .append("status", "A"),
        Document("item", "mousepad")
            .append("qty", 25)
            .append("size", Document("h", 19).append("w", 22.85).append("uom", "cm"))
            .append("status", "P"),
        Document("item", "notebook")
            .append("qty", 50)
            .append("size", Document("h", 8.5).append("w", 11).append("uom", "in"))
            .append("status", "P"),
        Document("item", "paper")
            .append("qty", 100)
            .append("size", Document("h", 8.5).append("w", 11).append("uom", "in"))
            .append("status", "D"),
        Document("item", "planner")
            .append("qty", 75)
            .append("size", Document("h", 22.85).append("w", 30).append("uom", "cm"))
            .append("status", "D"),
        Document("item", "postcard")
            .append("qty", 45)
            .append("size", Document("h", 10).append("w", 15.25).append("uom", "cm"))
            .append("status", "A"),
        Document("item", "sketchbook")
            .append("qty", 80)
            .append("size", Document("h", 14).append("w", 21).append("uom", "cm"))
            .append("status", "A"),
        Document("item", "sketch pad")
            .append("qty", 95)
            .append("size", Document("h", 22.85).append("w", 30.5).append("uom", "cm"))
            .append("status", "A"),
    )
)
await db.inventory.insert_many(
    [
        {
            "item": "canvas",
            "qty": 100,
            "size": {"h": 28, "w": 35.5, "uom": "cm"},
            "status": "A",
        },
        {
            "item": "journal",
            "qty": 25,
            "size": {"h": 14, "w": 21, "uom": "cm"},
            "status": "A",
        },
        {
            "item": "mat",
            "qty": 85,
            "size": {"h": 27.9, "w": 35.5, "uom": "cm"},
            "status": "A",
        },
        {
            "item": "mousepad",
            "qty": 25,
            "size": {"h": 19, "w": 22.85, "uom": "cm"},
            "status": "P",
        },
        {
            "item": "notebook",
            "qty": 50,
            "size": {"h": 8.5, "w": 11, "uom": "in"},
            "status": "P",
        },
        {
            "item": "paper",
            "qty": 100,
            "size": {"h": 8.5, "w": 11, "uom": "in"},
            "status": "D",
        },
        {
            "item": "planner",
            "qty": 75,
            "size": {"h": 22.85, "w": 30, "uom": "cm"},
            "status": "D",
        },
        {
            "item": "postcard",
            "qty": 45,
            "size": {"h": 10, "w": 15.25, "uom": "cm"},
            "status": "A",
        },
        {
            "item": "sketchbook",
            "qty": 80,
            "size": {"h": 14, "w": 21, "uom": "cm"},
            "status": "A",
        },
        {
            "item": "sketch pad",
            "qty": 95,
            "size": {"h": 22.85, "w": 30.5, "uom": "cm"},
            "status": "A",
        },
    ]
)
await db.collection('inventory').insertMany([
  {
    item: 'canvas',
    qty: 100,
    size: { h: 28, w: 35.5, uom: 'cm' },
    status: 'A'
  },
  {
    item: 'journal',
    qty: 25,
    size: { h: 14, w: 21, uom: 'cm' },
    status: 'A'
  },
  {
    item: 'mat',
    qty: 85,
    size: { h: 27.9, w: 35.5, uom: 'cm' },
    status: 'A'
  },
  {
    item: 'mousepad',
    qty: 25,
    size: { h: 19, w: 22.85, uom: 'cm' },
    status: 'P'
  },
  {
    item: 'notebook',
    qty: 50,
    size: { h: 8.5, w: 11, uom: 'in' },
    status: 'P'
  },
  {
    item: 'paper',
    qty: 100,
    size: { h: 8.5, w: 11, uom: 'in' },
    status: 'D'
  },
  {
    item: 'planner',
    qty: 75,
    size: { h: 22.85, w: 30, uom: 'cm' },
    status: 'D'
  },
  {
    item: 'postcard',
    qty: 45,
    size: { h: 10, w: 15.25, uom: 'cm' },
    status: 'A'
  },
  {
    item: 'sketchbook',
    qty: 80,
    size: { h: 14, w: 21, uom: 'cm' },
    status: 'A'
  },
  {
    item: 'sketch pad',
    qty: 95,
    size: { h: 22.85, w: 30.5, uom: 'cm' },
    status: 'A'
  }
]);
$db->coll("inventory")->insert_many(
    [
        {
            item   => "canvas",
            qty    => 100,
            size   => { h => 28, w => 35.5, uom => "cm" },
            status => "A"
        },
        {
            item   => "journal",
            qty    => 25,
            size   => { h => 14, w => 21, uom => "cm" },
            status => "A"
        },
        {
            item   => "mat",
            qty    => 85,
            size   => { h => 27.9, w => 35.5, uom => "cm" },
            status => "A"
        },
        {
            item   => "mousepad",
            qty    => 25,
            size   => { h => 19, w => 22.85, uom => "cm" },
            status => "P"
        },
        {
            item   => "notebook",
            qty    => 50,
            size   => { h => 8.5, w => 11, uom => "in" },
            status => "P"
        },
        {
            item   => "paper",
            qty    => 100,
            size   => { h => 8.5, w => 11, uom => "in" },
            status => "D"
        },
        {
            item   => "planner",
            qty    => 75,
            size   => { h => 22.85, w => 30, uom => "cm" },
            status => "D"
        },
        {
            item   => "postcard",
            qty    => 45,
            size   => { h => 10, w => 15.25, uom => "cm" },
            status => "A"
        },
        {
            item   => "sketchbook",
            qty    => 80,
            size   => { h => 14, w => 21, uom => "cm" },
            status => "A"
        },
        {
            item   => "sketch pad",
            qty    => 95,
            size   => { h => 22.85, w => 30.5, uom => "cm" },
            status => "A"
        }
    ]
);
$insertManyResult = $db->inventory->insertMany([
    [
        'item' => 'canvas',
        'qty' => 100,
        'size' => ['h' => 28, 'w' => 35.5, 'uom' => 'cm'],
        'status' => 'A',
    ],
    [
        'item' => 'journal',
        'qty' => 25,
        'size' => ['h' => 14, 'w' => 21, 'uom' => 'cm'],
        'status' => 'A',
    ],
    [
        'item' => 'mat',
        'qty' => 85,
        'size' => ['h' => 27.9, 'w' => 35.5, 'uom' => 'cm'],
        'status' => 'A',
    ],
    [
        'item' => 'mousepad',
        'qty' => 25,
        'size' => ['h' => 19, 'w' => 22.85, 'uom' => 'cm'],
        'status' => 'P',
    ],
    [
        'item' => 'notebook',
        'qty' => 50,
        'size' => ['h' => 8.5, 'w' => 11, 'uom' => 'in'],
        'status' => 'P',
    ],
    [
        'item' => 'paper',
        'qty' => 100,
        'size' => ['h' => 8.5, 'w' => 11, 'uom' => 'in'],
        'status' => 'D',
    ],
    [
        'item' => 'planner',
        'qty' => 75,
        'size' => ['h' => 22.85, 'w' => 30, 'uom' => 'cm'],
        'status' => 'D',
    ],
    [
        'item' => 'postcard',
        'qty' => 45,
        'size' => ['h' => 10, 'w' => 15.25, 'uom' => 'cm'],
        'status' => 'A',
    ],
    [
        'item' => 'sketchbook',
        'qty' => 80,
        'size' => ['h' => 14, 'w' => 21, 'uom' => 'cm'],
        'status' => 'A',
    ],
    [
        'item' => 'sketch pad',
        'qty' => 95,
        'size' => ['h' => 22.85, 'w' => 30.5, 'uom' => 'cm'],
        'status' => 'A',
    ],
]);
db.inventory.insert_many(
    [
        {
            "item": "canvas",
            "qty": 100,
            "size": {"h": 28, "w": 35.5, "uom": "cm"},
            "status": "A",
        },
        {
            "item": "journal",
            "qty": 25,
            "size": {"h": 14, "w": 21, "uom": "cm"},
            "status": "A",
        },
        {
            "item": "mat",
            "qty": 85,
            "size": {"h": 27.9, "w": 35.5, "uom": "cm"},
            "status": "A",
        },
        {
            "item": "mousepad",
            "qty": 25,
            "size": {"h": 19, "w": 22.85, "uom": "cm"},
            "status": "P",
        },
        {
            "item": "notebook",
            "qty": 50,
            "size": {"h": 8.5, "w": 11, "uom": "in"},
            "status": "P",
        },
        {
            "item": "paper",
            "qty": 100,
            "size": {"h": 8.5, "w": 11, "uom": "in"},
            "status": "D",
        },
        {
            "item": "planner",
            "qty": 75,
            "size": {"h": 22.85, "w": 30, "uom": "cm"},
            "status": "D",
        },
        {
            "item": "postcard",
            "qty": 45,
            "size": {"h": 10, "w": 15.25, "uom": "cm"},
            "status": "A",
        },
        {
            "item": "sketchbook",
            "qty": 80,
            "size": {"h": 14, "w": 21, "uom": "cm"},
            "status": "A",
        },
        {
            "item": "sketch pad",
            "qty": 95,
            "size": {"h": 22.85, "w": 30.5, "uom": "cm"},
            "status": "A",
        },
    ]
)
client[:inventory].insert_many([
                                { item: 'canvas',
                                  qty: 100,
                                  size: { h: 28, w: 35.5, uom: 'cm' },
                                  status: 'A' },
                                { item: 'journal',
                                  qty: 25,
                                  size: { h: 14, w: 21, uom: 'cm' },
                                  status: 'A' },
                                { item: 'mat',
                                  qty: 85,
                                  size: { h: 27.9, w: 35.5, uom: 'cm' },
                                  status: 'A' },
                                { item: 'mousepad',
                                  qty: 25,
                                  size: { h: 19, w: 22.85, uom: 'cm' },
                                  status: 'P' },
                                { item: 'notebook',
                                  qty: 50,
                                  size: { h: 8.5, w: 11, uom: 'in' },
                                  status: 'P' },
                                { item: 'paper',
                                  qty: 100,
                                  size: { h: 8.5, w: 11, uom: 'in' },
                                  status: 'D' },
                                { item: 'planner',
                                  qty: 75,
                                  size: { h: 22.85, w: 30, uom: 'cm' },
                                  status: 'D' },
                                { item: 'postcard',
                                  qty: 45,
                                  size: { h: 10, w: 15.25, uom: 'cm' },
                                  status: 'A' },
                                { item: 'sketchbook',
                                  qty: 80,
                                  size: { h: 14, w: 21, uom: 'cm' },
                                  status: 'A' },
                                { item: 'sketch pad',
                                  qty: 95,
                                  size: { h: 22.85, w: 30.5, uom: 'cm' },
                                  status: 'A' }
                              ])
collection.insertMany(Seq(
  Document("""{ item: "canvas", qty: 100, size: { h: 28, w: 35.5, uom: "cm" }, status: "A" }"""),
  Document("""{ item: "journal", qty: 25, size: { h: 14, w: 21, uom: "cm" }, status: "A" }"""),
  Document("""{ item: "mat", qty: 85, size: { h: 27.9, w: 35.5, uom: "cm" }, status: "A" }"""),
  Document("""{ item: "mousepad", qty: 25, size: { h: 19, w: 22.85, uom: "cm" }, status: "P" }"""),
  Document("""{ item: "notebook", qty: 50, size: { h: 8.5, w: 11, uom: "in" }, status: "P" }"""),
  Document("""{ item: "paper", qty: 100, size: { h: 8.5, w: 11, uom: "in" }, status: "D" }"""),
  Document("""{ item: "planner", qty: 75, size: { h: 22.85, w: 30, uom: "cm" }, status: "D" }"""),
  Document("""{ item: "postcard", qty: 45, size: { h: 10, w: 15.25, uom: "cm" }, status: "A" }"""),
  Document("""{ item: "sketchbook", qty: 80, size: { h: 14, w: 21, uom: "cm" }, status: "A" }"""),
  Document("""{ item: "sketch pad", qty: 95, size: { h: 22.85, w: 30.5, uom: "cm" }, status: "A" }""")
)).execute()

更新集合中的文档

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

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

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

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

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

单击编辑文档

单击铅笔图标后，文档进入编辑模式：

文档编辑模式

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

注意

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

更新单份文档

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

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

注意

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

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

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

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

以下示例使用 com.mongodb.reactivestreams.client.MongoCollection.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" 的文档：

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

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

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

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

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

更新操作：

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

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

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

  • 将 status 字段从 D 更改为 P。

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

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

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

    Access Table 视图

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

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

    { item: "paper" }
    查找纸质文档

  3. 将鼠标悬停在 status 字段上，然后单击文档右侧出现的铅笔图标以进入编辑模式：

    单击编辑按钮

  4. 将该字段的值更改为 "P"。

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

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

    展开尺寸对象

  7. 使用步骤 3-5 中概述的相同过程来编辑 status 字段，将 size.uom 字段的值更改为 "cm"。

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

    点击库存标签页

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

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

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

    在状态后添加字段

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

    提交更新

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

    注意

    由于 MongoDB Compass 不支持 $currentDate 或任何其他字段更新操作符，您必须在 Compass 中手动输入日期值。

mongoc_collection_t *collection;
bson_t *selector;
bson_t *update;
bool r;
bson_error_t error;
collection = mongoc_database_get_collection (db, "inventory");
selector = BCON_NEW ("item", BCON_UTF8 ("paper"));
update = BCON_NEW (
   "$set", "{",
   "size.uom", BCON_UTF8 ("cm"),
   "status", BCON_UTF8 ("P"),
   "}",
   "$currentDate", "{",
   "lastModified", BCON_BOOL (true),
   "}");
r = mongoc_collection_update_one(collection, selector, update, NULL, NULL, &error);
bson_destroy (selector);
bson_destroy (update);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}
var filter = Builders<BsonDocument>.Filter.Eq("item", "paper");
var update = Builders<BsonDocument>.Update.Set("size.uom", "cm").Set("status", "P").CurrentDate("lastModified");
var result = collection.UpdateOne(filter, update);

更新操作：

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

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

result, err := coll.UpdateOne(
	context.TODO(),
	bson.D{
		{"item", "paper"},
	},
	bson.D{
		{"$set", bson.D{
			{"size.uom", "cm"},
			{"status", "P"},
		}},
		{"$currentDate", bson.D{
			{"lastModified", true},
		}},
	},
)

更新操作：

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

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

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

更新操作：

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

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

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

更新操作：

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

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

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

更新操作：

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

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

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

更新操作：

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

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

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

更新操作：

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

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

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

更新操作：

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

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

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

更新操作：

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

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

db.inventory.update_one(
    {"item": "paper"},
    {"$set": {"size.uom": "cm", "status": "P"}, "$currentDate": {"lastModified": True}},
)
client[:inventory].update_one({ item: 'paper'},
                              { '$set' => { 'size.uom' => 'cm', 'status' => 'P' },
                                '$currentDate' => { 'lastModified' => true } })

更新操作：

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

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

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

更新操作：

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

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

更新多个文档

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

更新操作：

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

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

mongoc_collection_t *collection;
bson_t *selector;
bson_t *update;
bool r;
bson_error_t error;
collection = mongoc_database_get_collection (db, "inventory");
selector = BCON_NEW (
   "qty", "{",
   "$lt", BCON_INT64 (50),
   "}");
update = BCON_NEW (
   "$set", "{",
   "size.uom", BCON_UTF8 ("in"),
   "status", BCON_UTF8 ("P"),
   "}",
   "$currentDate", "{",
   "lastModified", BCON_BOOL (true),
   "}");
r = mongoc_collection_update_many(collection, selector, update, NULL, NULL, &error);
bson_destroy (selector);
bson_destroy (update);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}
var filter = Builders<BsonDocument>.Filter.Lt("qty", 50);
var update = Builders<BsonDocument>.Update.Set("size.uom", "in").Set("status", "P").CurrentDate("lastModified");
var result = collection.UpdateMany(filter, update);

更新操作：

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

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

result, err := coll.UpdateMany(
	context.TODO(),
	bson.D{
		{"qty", bson.D{
			{"$lt", 50},
		}},
	},
	bson.D{
		{"$set", bson.D{
			{"size.uom", "cm"},
			{"status", "P"},
		}},
		{"$currentDate", bson.D{
			{"lastModified", true},
		}},
	},
)

更新操作：

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

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

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

更新操作：

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

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

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

更新操作：

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

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

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

更新操作：

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

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

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

更新操作：

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

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

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

更新操作：

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

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

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

更新操作：

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

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

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

更新操作：

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

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

db.inventory.update_many(
    {"qty": {"$lt": 50}},
    {"$set": {"size.uom": "in", "status": "P"}, "$currentDate": {"lastModified": True}},
)
client[:inventory].update_many({ qty: { '$lt' => 50 } },
                              { '$set' => { 'size.uom' => 'in', 'status' => 'P' },
                                '$currentDate' => { 'lastModified' => true } })

更新操作：

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

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

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

更新操作：

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

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

替换文档

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

db.inventory.replaceOne(
   { item: "paper" },
   { item: "paper", instock: [ { warehouse: "A", qty: 60 }, { warehouse: "B", qty: 40 } ] }
)
mongoc_collection_t *collection;
bson_t *selector;
bson_t *replacement;
bool r;
bson_error_t error;
collection = mongoc_database_get_collection (db, "inventory");
selector = BCON_NEW ("item", BCON_UTF8 ("paper"));
replacement = BCON_NEW (
   "item", BCON_UTF8 ("paper"),
   "instock", "[",
   "{",
   "warehouse", BCON_UTF8 ("A"),
   "qty", BCON_INT64 (60),
   "}","{",
   "warehouse", BCON_UTF8 ("B"),
   "qty", BCON_INT64 (40),
   "}",
   "]");
/* MONGOC_UPDATE_NONE means "no special options" */
r = mongoc_collection_replace_one(collection, selector, replacement, NULL, NULL, &error);
bson_destroy (selector);
bson_destroy (replacement);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}

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

var filter = Builders<BsonDocument>.Filter.Eq("item", "paper");
var replacement = new BsonDocument
{
    { "item", "paper" },
    { "instock", new BsonArray
        {
            new BsonDocument { { "warehouse", "A" }, { "qty", 60 } },
            new BsonDocument { { "warehouse", "B" }, { "qty", 40 } } }
        }
};
var result = collection.ReplaceOne(filter, replacement);
result, err := coll.ReplaceOne(
	context.TODO(),
	bson.D{
		{"item", "paper"},
	},
	bson.D{
		{"item", "paper"},
		{"instock", bson.A{
			bson.D{
				{"warehouse", "A"},
				{"qty", 60},
			},
			bson.D{
				{"warehouse", "B"},
				{"qty", 40},
			},
		}},
	},
)
Publisher<UpdateResult> replaceOnePublisher = collection.replaceOne(eq("item", "paper"),
        Document.parse("{ item: 'paper', instock: [ { warehouse: 'A', qty: 60 }, { warehouse: 'B', qty: 40 } ] }"));
collection.replaceOne(eq("item", "paper"),
        Document.parse("{ item: 'paper', instock: [ { warehouse: 'A', qty: 60 }, { warehouse: 'B', qty: 40 } ] }"));
collection.replaceOne(eq("item", "paper"),
    Document.parse("{ item: 'paper', instock: [ { warehouse: 'A', qty: 60 }, { warehouse: 'B', qty: 40 } ] }"));
await db.inventory.replace_one(
    {"item": "paper"},
    {
        "item": "paper",
        "instock": [{"warehouse": "A", "qty": 60}, {"warehouse": "B", "qty": 40}],
    },
)
await db.collection('inventory').replaceOne(
  { item: 'paper' },
  {
    item: 'paper',
    instock: [
      { warehouse: 'A', qty: 60 },
      { warehouse: 'B', qty: 40 }
    ]
  }
);
$db->coll("inventory")->replace_one(
    { item => "paper" },
    {
        item    => "paper",
        instock => [ { warehouse => "A", qty => 60 }, { warehouse => "B", qty => 40 } ]
    }
);
$updateResult = $db->inventory->replaceOne(
    ['item' => 'paper'],
    [
        'item' => 'paper',
        'instock' => [
            ['warehouse' => 'A', 'qty' => 60],
            ['warehouse' => 'B', 'qty' => 40],
        ],
    ],
);
db.inventory.replace_one(
    {"item": "paper"},
    {
        "item": "paper",
        "instock": [{"warehouse": "A", "qty": 60}, {"warehouse": "B", "qty": 40}],
    },
)
client[:inventory].replace_one({ item: 'paper' },
                               { item: 'paper',
                                 instock: [ { warehouse: 'A', qty: 60 },
                                            { warehouse: 'B', qty: 40 } ] })
collection.replaceOne(equal("item", "paper"),
  Document("""{ item: "paper", instock: [ { warehouse: "A", qty: 60 }, { warehouse: "B", qty: 40 } ] }""")
).execute()

使用 MongoDB Atlas 更新文档

注意

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

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

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

1

在 MongoDB Atlas 用户界面中，前往您项目的Clusters 页面。<a class=\" \" href=\" \" title=\" \"><svg xmlns=\" \" width=\" \" height=\" \" fill=\" \" viewbox=\" \" class=\" \" role=\" \" aria-label=\" \"><path fill=\" \" d=\" \"> <path fill=\" \" d=\" \">

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

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

  3. 如果尚未出现，请单击侧边栏中的 Clusters（部署）。

    会显示集群页面。

2

导航至集合。

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

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

  3. 选择 sales 集合。

3

指定查询筛选文档。

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

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

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

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

4

Edit a document.

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

  • 添加新字段。

  • 删除现有字段。

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

  • 还原特定更改。

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

5

保存更改。

要确认并保存更改，请单击 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 包含设置为 true 的插入或更新选项 ，且没有与指定过滤器匹配的文档，则该操作会创建一个新文档并将其插入。如果存在匹配的文档，则该操作会修改或替换匹配的一个或多个文档。

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

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

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

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

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

如果更新和替换方法包含 com.mongodb. 客户端.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 请求的写操作确认级别。有关详细信息，请参阅写关注。

提示

另请参阅：

提示

另请参阅：

后退

在 mongosh 中迭代游标

来年

聚合管道 (Aggregation Pipeline)