插入文档

在此页面上

在 MongoDB Atlas 用户界面中插入文档

插入单一文档
插入多个文档
插入行为

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

本页提供 MongoDB 中插入操作的示例。

您可以使用以下方法在 MongoDB 中插入文档：

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

注意

创建集合

如果该集合当前不存在，则插入操作将创建该集合。

在 MongoDB Atlas 用户界面中插入文档

要在 MongoDB Atlas 用户界面中插入文档，请完成以下步骤。要了解在 MongoDB Atlas 用户界面中处理文档的更多信息，请参阅创建、查看、更新和删除文档。

在 MongoDB Atlas UIClusters 中，转到项目的页面。

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

导航至集合

对于要添加文档的集群，请单击 Browse Collections。
在左侧导航窗格中，选择数据库。
在左侧导航窗格中，选择该集合。

添加文档

单击 Insert Document（连接）。
点击{} {} 图标，打开 JSON 视图。

将文档数组粘贴到文本输入框中。例如，以下输入会创建四个文档，每个文档包含三个字段：

[
   { "prodId": 100, "price": 20, "quantity": 125 },
   { "prodId": 101, "price": 10, "quantity": 234 },
   { "prodId": 102, "price": 15, "quantity": 432 },
   { "prodId": 103, "price": 17, "quantity": 320 }
]

单击“插入”。

MongoDB Atlas 会将文档添加到集合中。

插入单一文档

db.collection.insertOne() 将单个文档插入集合。

以下示例将新文档插入 inventory 集合。如果文档未指定 _id 字段，MongoDB 会将具有 ObjectId 值的 _id 字段添加到新文档中。请参阅插入行为。

要使用 MongoDB Compass 插入单个文档，请执行以下操作：

导航到要插入文档的集合：
1. 在左侧 MongoDB Compass 导航窗格中，单击包含目标集合的数据库。
2. 在数据库视图中，点击目标集合的名称。
点击 Insert Document 按钮：
对于文档中的每个字段，选择字段类型并填写字段名称和值。单击最后一个行号以添加字段，然后单击 Add Field After ...
- 对于 Object类型，通过单击最后一个字段的编号并选择 Add Field After ... 来添加嵌套字段
- 对于 Array 类型，通过单击最后一个元素的行号并选择 Add Array Element After ... 来向数组中添加其他元素
填写所有字段后，单击 Insert。

以下示例将新文档插入 test.inventory 集合：

以下示例将新文档插入inventory集合。如果文档未指定_id字段， C驾驶员会将具有 ObjectId 值的_id字段添加到新文档中。有关详细信息，请参阅插入行为。

IMongoCollection.InsertOne() 将单个文档插入到集合中。

以下示例将新文档插入 inventory 集合。如果文档未指定 _id 字段，C# 驱动程序会将具有 ObjectId 值的 _id 字段添加到新文档中。请参阅插入行为。

Collection.InsertOne 将单个文档插入到集合中。

以下示例将新文档插入inventory集合。如果文档未指定_id字段，驱动程序会将具有 ObjectId 值的_id字段添加到新文档中。请参阅插入行为。

com.mongodb.reactivestreams.client.MongoCollection.insertOne 使用Java Reactive Streams 驱动程序将单个文档插入到集合：

{ item: "canvas", qty: 100, tags: ["cotton"], size: { h: 28, w: 35.5, uom: "cm" } }

以下示例将上述文档插入 inventory 集合。如果文档未指定 _id 字段，驱动程序会将具有 ObjectId 值的 _id 字段添加到新文档中。请参阅插入行为。

com.mongodb.client.MongoCollection.insertOne 将单个文档插入到集合中。

以下示例将新文档插入inventory集合。如果文档未指定_id字段，驱动程序会将具有 ObjectId 值的_id字段添加到新文档中。请参阅插入行为。

MongoCollection.insertOne 将单个文档插入到集合中。

以下示例将新文档插入inventory集合。如果文档未指定_id字段，驱动程序会将具有 ObjectId 值的_id字段添加到新文档中。请参阅插入行为。

motor.motor_asyncio.AsyncIOMotorCollection.insert_one 将单个文档插入集合。

以下示例将新文档插入 inventory 集合。如果文档未指定 _id 字段，Motor 驱动程序会将具有 ObjectId 值的 _id 字段添加到新文档中。请参阅插入行为。

Collection.insertOne()将单个文档插入到集合中。

以下示例将新文档插入 inventory 集合。如果文档未指定 _id 字段，Node.js 驱动程序会将具有 ObjectId 值的 _id 字段添加到新文档中。请参阅插入行为。

MongoDB::Collection::insert_one() 将单个文档插入集合。

以下示例将新文档插入 inventory 集合。如果文档未指定 _id 字段，Perl 驱动程序会将具有 ObjectId 值的 _id 字段添加到新文档中。请参阅插入行为。

MongoDB\\Collection::insertOne() 将单个文档插入集合。

以下示例将新文档插入 inventory 集合。如果文档未指定 _id 字段，PHP 驱动程序会将具有 ObjectId 值的 _id 字段添加到新文档中。请参阅插入行为。

pymongo.collection.Collection.insert_one 将单个文档插入集合。

以下示例将新文档插入 inventory 集合。如果文档未指定 _id 字段，PyMongo 驱动程序会将具有 ObjectId 值的 _id 字段添加到新文档中。请参阅插入行为。

Mongo:: Collection #insert_one () 将单个文档插入集合。

以下示例将新文档插入 inventory 集合。如果文档未指定 _id 字段，Ruby 驱动程序会将具有 ObjectId 值的 _id 字段添加到新文档中。请参阅插入行为。

collection.insertOne() 将单个文档插入到集合中。

以下示例将新文档插入 inventory 集合。如果文档未指定 _id 字段，Scala 驱动程序会将具有 ObjectId 值的 _id 字段添加到新文档。请参阅插入行为。

db.inventory.insertOne(
   { item: "canvas", qty: 100, tags: ["cotton"], size: { h: 28, w: 35.5, uom: "cm" } }
)

mongoc_collection_t *collection;
bson_t *doc;
bool r;
bson_error_t error;
collection = mongoc_database_get_collection (db, "inventory");
doc = BCON_NEW (
   "item", BCON_UTF8 ("canvas"),
   "qty", BCON_INT64 (100),
   "tags", "[",
   BCON_UTF8 ("cotton"),
   "]",
   "size", "{",
   "h", BCON_DOUBLE (28),
   "w", BCON_DOUBLE (35.5),
   "uom", BCON_UTF8 ("cm"),
   "}");
r = mongoc_collection_insert_one (collection, doc, NULL, NULL, &error);
bson_destroy (doc);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}

var document = new BsonDocument
{
    { "item", "canvas" },
    { "qty", 100 },
    { "tags", new BsonArray { "cotton" } },
    { "size", new BsonDocument { { "h", 28 }, { "w", 35.5 }, { "uom", "cm" } } }
};
collection.InsertOne(document);

result, err := coll.InsertOne(
	context.TODO(),
	bson.D{
		{"item", "canvas"},
		{"qty", 100},
		{"tags", bson.A{"cotton"}},
		{"size", bson.D{
			{"h", 28},
			{"w", 35.5},
			{"uom", "cm"},
		}},
	})

Document canvas = new Document("item", "canvas")
        .append("qty", 100)
        .append("tags", singletonList("cotton"));
Document size = new Document("h", 28)
        .append("w", 35.5)
        .append("uom", "cm");
canvas.put("size", size);
Publisher<Success> insertOnePublisher = collection.insertOne(canvas);

Document canvas = new Document("item", "canvas")
        .append("qty", 100)
        .append("tags", singletonList("cotton"));
Document size = new Document("h", 28)
        .append("w", 35.5)
        .append("uom", "cm");
canvas.put("size", size);
collection.insertOne(canvas);

result = collection.insertOne(
Document("item", "canvas")
    .append("qty", 100)
    .append("tags", listOf("cotton"))
    .append("size", Document("h", 28)
        .append("w", 35.5)
        .append("uom", "cm")
    )

await db.inventory.insert_one(
    {
        "item": "canvas",
        "qty": 100,
        "tags": ["cotton"],
        "size": {"h": 28, "w": 35.5, "uom": "cm"},
    }
)

await db.collection('inventory').insertOne({
  item: 'canvas',
  qty: 100,
  tags: ['cotton'],
  size: { h: 28, w: 35.5, uom: 'cm' }
});

$db->coll("inventory")->insert_one(
    {
        item => "canvas",
        qty  => 100,
        tags => ["cotton"],
        size => { h => 28, w => 35.5, uom => "cm" }
    }
);

$insertOneResult = $db->inventory->insertOne([
    'item' => 'canvas',
    'qty' => 100,
    'tags' => ['cotton'],
    'size' => ['h' => 28, 'w' => 35.5, 'uom' => 'cm'],
]);

db.inventory.insert_one(
    {
        "item": "canvas",
        "qty": 100,
        "tags": ["cotton"],
        "size": {"h": 28, "w": 35.5, "uom": "cm"},
    }
)

client[:inventory].insert_one({ item: 'canvas',
                                qty: 100,
                                tags: [ 'cotton' ],
                                size: { h: 28, w: 35.5, uom: 'cm' } })

collection.insertOne(
  Document("item" -> "canvas", "qty" -> 100, "tags" -> Seq("cotton"), "size" -> Document("h" -> 28, "w" -> 35.5, "uom" -> "cm"))
).execute()

insertOne() 将返回一个文档，其中包含新插入的文档的 _id 字段值。有关返回文档的示例，请参阅 db.collection.insertOne() 引用。

注意

MongoDB Compass 会自动生成 _id 字段及其值。生成的 ObjectID 由一个随机生成的唯一十六进制值组成。

您可以在插入文档之前更改此值，只要它保持唯一并且是有效的 ObjectId。有关 _id 字段的更多信息，请参阅 _id 字段。

mongoc_collection_insert_one true如果成功，则返回false ；或者，如果参数无效、服务器或网络错误，则返回并设置错误。

Collection.InsertOne 函数返回 InsertOneResult 的一个实例，其 InsertedID 属性包含新插入文档的 _id。

com.mongodb.reactivestreams。客户端.MongoCollection.insertOne 返回发布者对象。当订阅者请求数据时， Publisher会将文档插入到集合中。

com.mongodb.client.MongoCollection.insertOne 返回 InsertOneResult 的实例。您可以通过调用_id getInsertedId() 来访问插入文档的字段方法。

MongoCollection.insertOne 返回 InsertOneResult 的实例。您可以通过访问权限结果的_id 字段来访问插入文档的insertedId 字段。

insert_one返回 pymongo.results.InsertOneResult 的一个实例，其 inserted_id 字段包含新插入文档的 _id 字段。

insertOne() 会返回一个提供 result 的 Promise。result.insertedId Promise 包含新插入文档的 _id。

插入成功后，insert_one() 方法会返回 MongoDB::InsertOneResult 实例，其 inserted_id 属性包含新插入文档的 _id。

成功插入后，insertOne() 方法会返回一个 MongoDB\\InsertOneResult 实例，其 getInsertedId() 方法返回新插入文档的 _id。

insert_one返回 pymongo.results.InsertOneResult 的一个实例，其 inserted_id 字段包含新插入文档的 _id 字段。

成功插入后，insert_one () 方法返回 Mongo::Operation::Result 的实例，其 inserted_id 属性包含新插入文档的 _id。

成功插入后，collection.insertOne() 方法会返回一个 collection.insertOne().results(); 实例其 inserted_id 属性包含新插入文档的 _id。

要检索刚刚插入的文档，请查询该集合：

db.inventory.find( { item: "canvas" } )

在 MongoDB Compass 查询栏中指定过滤器，然后单击 Find 以执行查询。

上述过滤器指定 MongoDB Compass 仅返回 item 字段等于 canvas 的文档。

有关 MongoDB Compass 查询栏的更多信息，请参阅 Compass 查询栏文档。

mongoc_collection_t *collection;
bson_t *filter;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW ("item", BCON_UTF8 ("canvas"));
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);

var filter = Builders<BsonDocument>.Filter.Eq("item", "canvas");
var result = collection.Find(filter).ToList();

cursor, err := coll.Find(
	context.TODO(),
	bson.D{{"item", "canvas"}},
)

FindPublisher<Document> findPublisher = collection.find(eq("item", "canvas"));

FindIterable<Document> findIterable = collection.find(eq("item", "canvas"));

val flowInsertOne = collection
    .find(eq("item", "canvas"))
    .firstOrNull()

cursor = db.inventory.find({"item": "canvas"})

const cursor = db.collection('inventory').find({ item: 'canvas' });

$cursor = $db->coll("inventory")->find( { item => "canvas" } );

$cursor = $db->inventory->find(['item' => 'canvas']);

cursor = db.inventory.find({"item": "canvas"})

client[:inventory].find(item: 'canvas')

val observable = collection.find(equal("item", "canvas"))

插入多个文档

db.collection.insertMany() 可以将多个文档插入到一个集合中。将一组文档传递给该方法。

以下示例将三个新文档插入到 inventory 集合中。如果文档未指定 _id 字段，MongoDB 会将具有 ObjectId 值的 _id 字段添加到每个文档中。请参阅插入行为。

mongoc_bulk_operation_insert_with_opts 将多个文档插入到一个集合中。您必须将文档的可迭代对象传递给该方法。

以下示例将三个新文档插入inventory集合。如果文档未指定_id字段， C驾驶员会将具有 ObjectId 值的_id字段添加到每个文档中。请参阅插入行为。

imongoCollection.insertMany() 可以将多个文档插入到一个集合中。将可枚举的文档集合传递给该方法。

以下示例将三个新文档插入到 inventory 集合中。如果文档未指定 _id 字段，驱动程序会将带有 ObjectId 值的 _id 字段添加到每个文档。请参阅插入行为。

Collection.InsertMany 可以将多个文档插入集合。

com.mongodb.reactivestreams.client.MongoCollection.html.insertMany 使用 Java Reactive Streams 驱动程序插入以下文档：

{ item: "journal", qty: 25, tags: ["blank", "red"], size: { h: 14, w: 21, uom: "cm" } }
{ item: "mat", qty: 85, tags: ["gray"], size: { h: 27.9, w: 35.5, uom: "cm" } }
{ item: "mousepad", qty: 25, tags: ["gel", "blue"], size: { h: 19, w: 22.85, uom: "cm" } }

com.mongodb.client.MongoCollection.insertMany 可将多个文档插入到一个集合中。将文档列表传递给该方法。

MongoCollection.insertMany 将多个文档插入到一个集合中。将文档列表作为参数传递给该方法。

以下示例将三个新文档插入inventory集合。如果文档未指定_id字段，驾驶员则会向每个文档添加一个 ObjectId 值。请参阅插入行为。

motor.motor_asyncio.AsyncIOMotorCollection.insert_many可以将多个文档插入到一个集合中。将可迭代的文档传递给该方法。

以下示例将三个新文档插入 inventory 集合。如果文档未指定 _id 字段，PyMongo 驱动程序会将带有 ObjectId 值的 _id 字段添加到每个文档。请参阅插入行为。

Collection.insertMany() 可以在一个集合中插入多个文档。将文档数组传递给该方法。

以下示例将三个新文档插入 inventory 集合。如果文档未指定 _id 字段，Node.js 驱动程序会将带有 ObjectId 值的 _id 字段添加到每个文档。请参阅插入行为。

MongoDB::Collection::insert_many() 可将多个文档插入集合。将文档数组引用传递给该方法。

以下示例将三个新文档插入 inventory 集合。如果文档未指定 _id 字段，Perl 驱动程序会将带有 ObjectId 值的 _id 字段添加到每个文档。请参阅插入行为。

MongoDB\\Collection::insertMany() 可以将多个文档插入到一个集合中。将文档数组传递给该方法。

以下示例将三个新文档插入 inventory 集合。如果文档未指定 _id 字段，PHP 驱动程序会将带有 ObjectId 值的 _id 字段添加到每个文档。请参阅插入行为。

pymongo.collection.Collection.insert_many可以将多个文档插入到一个集合中。将可迭代的文档传递给该方法。

Mongo::Collection#insert_many() 可将多个文档插入到集合。将文档数组传递给该方法。

以下示例将三个新文档插入 inventory 集合。如果文档未指定 _id 字段，Ruby 驱动程序会将带有 ObjectId 值的 _id 字段添加到每个文档。请参阅插入行为。

collection.insertMany() 可以将多个文档插入集合。

以下示例将三个新文档插入到 inventory 集合中。如果文档未指定 _id 字段，Scala 驱动程序会将带有 ObjectId 值的 _id 字段添加到每个文档中。请参阅插入行为。

db.inventory.insertMany([
   { item: "journal", qty: 25, tags: ["blank", "red"], size: { h: 14, w: 21, uom: "cm" } },
   { item: "mat", qty: 85, tags: ["gray"], size: { h: 27.9, w: 35.5, uom: "cm" } },
   { item: "mousepad", qty: 25, tags: ["gel", "blue"], size: { h: 19, w: 22.85, uom: "cm" } }
])

[
    { "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 ("journal"),
   "qty", BCON_INT64 (25),
   "tags", "[",
   BCON_UTF8 ("blank"), BCON_UTF8 ("red"),
   "]",
   "size", "{",
   "h", BCON_DOUBLE (14),
   "w", BCON_DOUBLE (21),
   "uom", BCON_UTF8 ("cm"),
   "}");
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),
   "tags", "[",
   BCON_UTF8 ("gray"),
   "]",
   "size", "{",
   "h", BCON_DOUBLE (27.9),
   "w", BCON_DOUBLE (35.5),
   "uom", BCON_UTF8 ("cm"),
   "}");
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),
   "tags", "[",
   BCON_UTF8 ("gel"), BCON_UTF8 ("blue"),
   "]",
   "size", "{",
   "h", BCON_DOUBLE (19),
   "w", BCON_DOUBLE (22.85),
   "uom", BCON_UTF8 ("cm"),
   "}");
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 BsonDocument[]
{
    new BsonDocument
    {
        { "item", "journal" },
        { "qty", 25 },
        { "tags", new BsonArray { "blank", "red" } },
        { "size", new BsonDocument { { "h", 14 }, { "w", 21 }, {  "uom", "cm"} } }
    },
    new BsonDocument
    {
        { "item", "mat" },
        { "qty", 85 },
        { "tags", new BsonArray { "gray" } },
        { "size", new BsonDocument { { "h", 27.9 }, { "w", 35.5 }, {  "uom", "cm"} } }
    },
    new BsonDocument
    {
        { "item", "mousepad" },
        { "qty", 25 },
        { "tags", new BsonArray { "gel", "blue" } },
        { "size", new BsonDocument { { "h", 19 }, { "w", 22.85 }, {  "uom", "cm"} } }
    },
};
collection.InsertMany(documents);

result, err := coll.InsertMany(
	context.TODO(),
	[]interface{}{
		bson.D{
			{"item", "journal"},
			{"qty", int32(25)},
			{"tags", bson.A{"blank", "red"}},
			{"size", bson.D{
				{"h", 14},
				{"w", 21},
				{"uom", "cm"},
			}},
		},
		bson.D{
			{"item", "mat"},
			{"qty", int32(25)},
			{"tags", bson.A{"gray"}},
			{"size", bson.D{
				{"h", 27.9},
				{"w", 35.5},
				{"uom", "cm"},
			}},
		},
		bson.D{
			{"item", "mousepad"},
			{"qty", 25},
			{"tags", bson.A{"gel", "blue"}},
			{"size", bson.D{
				{"h", 19},
				{"w", 22.85},
				{"uom", "cm"},
			}},
		},
	})

Document journal = new Document("item", "journal")
        .append("qty", 25)
        .append("tags", asList("blank", "red"));
Document journalSize = new Document("h", 14)
        .append("w", 21)
        .append("uom", "cm");
journal.put("size", journalSize);
Document mat = new Document("item", "mat")
        .append("qty", 85)
        .append("tags", singletonList("gray"));
Document matSize = new Document("h", 27.9)
        .append("w", 35.5)
        .append("uom", "cm");
mat.put("size", matSize);
Document mousePad = new Document("item", "mousePad")
        .append("qty", 25)
        .append("tags", asList("gel", "blue"));
Document mousePadSize = new Document("h", 19)
        .append("w", 22.85)
        .append("uom", "cm");
mousePad.put("size", mousePadSize);
Publisher<Success> insertManyPublisher = collection.insertMany(asList(journal, mat, mousePad));

Document journal = new Document("item", "journal")
        .append("qty", 25)
        .append("tags", asList("blank", "red"));
Document journalSize = new Document("h", 14)
        .append("w", 21)
        .append("uom", "cm");
journal.put("size", journalSize);
Document mat = new Document("item", "mat")
        .append("qty", 85)
        .append("tags", singletonList("gray"));
Document matSize = new Document("h", 27.9)
        .append("w", 35.5)
        .append("uom", "cm");
mat.put("size", matSize);
Document mousePad = new Document("item", "mousePad")
        .append("qty", 25)
        .append("tags", asList("gel", "blue"));
Document mousePadSize = new Document("h", 19)
        .append("w", 22.85)
        .append("uom", "cm");
mousePad.put("size", mousePadSize);
collection.insertMany(asList(journal, mat, mousePad));

results = collection.insertMany(
listOf(
    Document("item", "journal")
        .append("qty", 25)
        .append("tags", listOf("blank", "red"))
        .append("size", Document("h", 14)
            .append("w", 21)
            .append("uom", "cm")
        ),
    Document("item", "mat")
        .append("qty", 25)
        .append("tags", listOf("gray"))
        .append("size", Document("h", 27.9)
            .append("w", 35.5)
            .append("uom", "cm")
        ),
    Document("item", "mousepad")
        .append("qty", 25)
        .append("tags", listOf("gel", "blue"))
        .append("size", Document("h", 19)
            .append("w", 22.85)
            .append("uom", "cm")
        )
)

await db.inventory.insert_many(
    [
        {
            "item": "journal",
            "qty": 25,
            "tags": ["blank", "red"],
            "size": {"h": 14, "w": 21, "uom": "cm"},
        },
        {
            "item": "mat",
            "qty": 85,
            "tags": ["gray"],
            "size": {"h": 27.9, "w": 35.5, "uom": "cm"},
        },
        {
            "item": "mousepad",
            "qty": 25,
            "tags": ["gel", "blue"],
            "size": {"h": 19, "w": 22.85, "uom": "cm"},
        },
    ]
)

await db.collection('inventory').insertMany([
  {
    item: 'journal',
    qty: 25,
    tags: ['blank', 'red'],
    size: { h: 14, w: 21, uom: 'cm' }
  },
  {
    item: 'mat',
    qty: 85,
    tags: ['gray'],
    size: { h: 27.9, w: 35.5, uom: 'cm' }
  },
  {
    item: 'mousepad',
    qty: 25,
    tags: ['gel', 'blue'],
    size: { h: 19, w: 22.85, uom: 'cm' }
  }
]);

$db->coll("inventory")->insert_many(
    [
        {
            item => "journal",
            qty  => 25,
            tags => [ "blank", "red" ],
            size => { h => 14, w => 21, uom => "cm" }
        },
        {
            item => "mat",
            qty  => 85,
            tags => ["gray"],
            size => { h => 27.9, w => 35.5, uom => "cm" }
        },
        {
            item => "mousepad",
            qty  => 25,
            tags => [ "gel", "blue" ],
            size => { h => 19, w => 22.85, uom => "cm" }
        }
    ]
);

$insertManyResult = $db->inventory->insertMany([
    [
        'item' => 'journal',
        'qty' => 25,
        'tags' => ['blank', 'red'],
        'size' => ['h' => 14, 'w' => 21, 'uom' => 'cm'],
    ],
    [
        'item' => 'mat',
        'qty' => 85,
        'tags' => ['gray'],
        'size' => ['h' => 27.9, 'w' => 35.5, 'uom' => 'cm'],
    ],
    [
        'item' => 'mousepad',
        'qty' => 25,
        'tags' => ['gel', 'blue'],
        'size' => ['h' => 19, 'w' => 22.85, 'uom' => 'cm'],
    ],
]);

db.inventory.insert_many(
    [
        {
            "item": "journal",
            "qty": 25,
            "tags": ["blank", "red"],
            "size": {"h": 14, "w": 21, "uom": "cm"},
        },
        {
            "item": "mat",
            "qty": 85,
            "tags": ["gray"],
            "size": {"h": 27.9, "w": 35.5, "uom": "cm"},
        },
        {
            "item": "mousepad",
            "qty": 25,
            "tags": ["gel", "blue"],
            "size": {"h": 19, "w": 22.85, "uom": "cm"},
        },
    ]
)

client[:inventory].insert_many([{ item: 'journal',
                                  qty: 25,
                                  tags: ['blank', 'red'],
                                  size: { h: 14, w: 21, uom: 'cm' }
                                },
                                { item: 'mat',
                                  qty: 85,
                                  tags: ['gray'],
                                  size: { h: 27.9, w: 35.5, uom: 'cm' }
                                },
                                { item: 'mousepad',
                                  qty: 25,
                                  tags: ['gel', 'blue'],
                                  size: { h: 19, w: 22.85, uom: 'cm' }
                                }
                               ])

collection.insertMany(Seq(
  Document("item" -> "journal", "qty" -> 25, "tags" -> Seq("blank", "red"), "size" -> Document("h" -> 14, "w" -> 21, "uom" -> "cm")),
  Document("item" -> "mat", "qty" -> 85, "tags" -> Seq("gray"), "size" -> Document("h" -> 27.9, "w" -> 35.5, "uom" -> "cm")),
  Document("item" -> "mousepad", "qty" -> 25, "tags" -> Seq("gel", "blue"), "size" -> Document("h" -> 19, "w" -> 22.85, "uom" -> "cm"))
)).execute()

insertMany() 返回一个包含新插入文档的 _id 字段值的文档。有关示例，请参阅参考资料。

要检索插入的文档，请查询集合：

mongoc_bulk_operation_insert_with_opts true成功时返回false ，如果传递的参数无效，则返回。

要检索插入的文档，请使用 mongoc_collection_find_with_opts 查询集合：

要检索插入的文档，请查询集合：

com.mongodb.reactivestreams.client.MongoCollection.html.insertMany返回Publisher对象。当订阅者请求数据时，Publisher 会将文档插入到集合中。

要检索插入的文档，请查询集合：

MongoCollection.insertMany() 返回一个InsertManyResult 实例。InsertManyResult的insertedIds字段包含插入文档的_id值。

要检索插入的文档，请查询集合：

insert_many 返回 pymongo.results.InsertManyResult 的实例，其 inserted_ids 字段是包含每个新插入文档的 _id 的列表。

要检索插入的文档，请查询集合：

insertMany() 会返回一个提供 result 的 Promise。result.insertedIds 字段包含一个数组，其中包含每个新插入文档的 _id。

要检索插入的文档，请查询集合：

成功插入后，insert_many() 方法会返回一个 MongoDB::InsertManyResult 实例，其 inserted_ids 属性是一个包含每个新插入文档的 _id 的列表。

要检索插入的文档，请查询集合：

成功插入后，insertMany() 方法会返回一个 MongoDB\\InsertManyResult 实例，其 getInsertedIds() 方法会返回每个新插入的文档的 _id。

要检索插入的文档，请查询集合：

insert_many 返回 pymongo.results.InsertManyResult 的实例，其 inserted_ids 字段是包含每个新插入文档的 _id 的列表。

要检索插入的文档，请查询集合：

成功插入后，insert_many() 方法会返回一个 Mongo::BulkWrite::Result 实例，其 inserted_ids 属性是一个包含每个新插入文档的 _id 的列表。

要检索插入的文档，请查询集合：

插入成功后，insertMany() 方法会返回一个 Observable，其中带有一个类型参数，指示操作何时完成，或带有 com.mongodb.DuplicateKeyException 或 com.mongodb.MongoException。

要检索插入的文档，请查询集合：

db.inventory.find( {} )

mongoc_collection_t *collection;
bson_t *filter;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW (NULL);
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);

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

var filter = Builders<BsonDocument>.Filter.Empty;
var result = collection.Find(filter).ToList();

cursor, err := coll.Find(
	context.TODO(),
	bson.D{},
)

FindPublisher<Document> findPublisher = collection.find(new Document());

FindIterable<Document> findIterable = collection.find(new Document());

val flowInsertMany = collection
    .find(empty())

cursor = db.inventory.find({})

const cursor = db.collection('inventory').find({});

$cursor = $db->coll("inventory")->find( {} );

$cursor = $db->inventory->find([]);

cursor = db.inventory.find({})

client[:inventory].find({})

var findObservable = collection.find(Document())

插入行为

创建集合

如果该集合当前不存在，则插入操作将创建该集合。

`_id` 字段

在 MongoDB 中，存储在集合中的每个文档都需要一个唯一的 _id 字段作为主键。如果插入的文档省略了 _id 字段，MongoDB 驱动程序会自动为 _id 字段生成一个 ObjectId。

这也适用于通过执行 upsert: true 的更新操作插入的文档。

原子性(Atomicity)

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

写确认

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

注意

创建集合

在 MongoDB Atlas 用户界面中插入文档

在 MongoDB Atlas UI.css-h15tq0{font-style:normal;font-weight:700;}Clusters 中，转到项目的 页面。

导航至集合

添加文档

单击“插入”。

插入单一文档

注意

插入多个文档

插入行为

创建集合

_id 字段

原子性(Atomicity)

写确认

提示

另请参阅：

提示

另请参阅：

提示

另请参阅：

提示

另请参阅：

提示

另请参阅：

提示

另请参阅：

提示

另请参阅：

提示

另请参阅：

提示

另请参阅：

提示

另请参阅：

提示

另请参阅：

提示

另请参阅：

提示

另请参阅：

提示

另请参阅：

在 MongoDB Atlas UIClusters 中，转到项目的页面。

`_id` 字段