Insert Documents插入文档

db.collection.insertOne() inserts a single document into a collection.db.collection.insertOne()将单个文档插入到集合中。

The following example inserts a new document into the inventory collection. 以下示例将新文档插入到inventory集合中。If the document does not specify an _id field, MongoDB adds the _id field with an ObjectId value to the new document. 如果文档没有指定_id字段，MongoDB会将具有ObjectId值的_id字段添加到新文档中。See Insert Behavior.请参见插入行为。

To insert a single document using MongoDB Compass:要使用MongoDB Compass插入单个文档，请执行以下操作：

1. Navigate to the collection you wish to insert the document into:导航到要将文档插入的集合：
   1. In the left-hand MongoDB Compass navigation pane, click the database to which your target collection belongs.在左侧的MongoDB Compass导航窗格中，单击目标集合所属的数据库。
   2. From the database view, click the target collection name.在数据库视图中，单击目标集合名称。
2. Click the Add Data button, then click Insert document:单击“添加数据”按钮，然后单击“插入文档”：

   

3. Paste in your document. For example, you can paste the following code into Compass to insert a canvas document into the inventory collection:粘贴到文档中。例如，您可以将以下代码粘贴到Compass中，将canvas文档插入到inventory集合中：

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

4. Click Insert.单击“插入”。

The following example inserts a new document into the test.inventory collection:以下示例将新文档插入到test.inventory集合中：

The following example inserts a new document into the inventory collection. 以下示例将新文档插入到inventory集合中。If the document does not specify an _id field, the C driver adds the _id field with an ObjectId value to the new document. 如果文档没有指定_id字段，C驱动程序会将具有ObjectId值的_id字段添加到新文档中。For more information, see Insert Behavior.有关详细信息，请参阅插入行为。

IMongoCollection.InsertOne() inserts a single document into a collection.将单个文档插入到集合中。

The following example inserts a new document into the inventory collection. If the document does not specify an _id field, the C# driver adds the _id field with an ObjectId value to the new document. 以下示例将新文档插入到inventory集合中。如果文档没有指定_id字段，C#驱动程序会将具有ObjectId值的_id字段添加到新文档中。See Insert Behavior.请参见插入行为。

Collection.InsertOne inserts a single document into a collection.将单个文档插入到集合中。

The following example inserts a new document into the inventory collection. If the document does not specify an _id field, the driver adds the _id field with an ObjectId value to the new document. 以下示例将新文档插入到inventory集合中。如果文档没有指定_id字段，驱动程序会将具有ObjectId值的_id字段添加到新文档中。See Insert Behavior.请参见插入行为。

com.mongodb.reactivestreams.client.MongoCollection.insertOne inserts a single document into a collection with the Java Reactive Streams Driver:使用Java Reactive Streams驱动程序将单个文档插入到集合中：

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

The following example inserts the document above into the inventory collection. 以下示例将上述文档插入到inventory集合中。If the document does not specify an _id field, the driver adds the _id field with an ObjectId value to the new document. 如果文档没有指定_id字段，驱动程序会将具有ObjectId值的_id字段添加到新文档中。See Insert Behavior.请参见插入行为。

com.mongodb.client.MongoCollection.insertOne inserts a single document into a collection.

The following example inserts a new document into the inventory collection. If the document does not specify an _id field, the driver adds the _id field with an ObjectId value to the new document. See Insert Behavior.以下示例将新文档插入到inventory集合中。如果文档没有指定_id字段，驱动程序会将具有ObjectId值的_id字段添加到新文档中。请参见插入行为。

MongoCollection.insertOne inserts a single document into a collection.将单个文档插入到集合中。

The following example inserts a new document into the inventory collection. If the document does not specify an _id field, the driver adds the _id field with an ObjectId value to the new document. 以下示例将新文档插入到inventory集合中。如果文档没有指定_id字段，驱动程序会将具有ObjectId值的_id字段添加到新文档中。See Insert Behavior.请参见插入行为。

motor.motor_asyncio.AsyncIOMotorCollection.insert_one inserts a single document into a collection.将单个文档插入到集合中。

The following example inserts a new document into the inventory collection. If the document does not specify an _id field, the Motor driver adds the _id field with an ObjectId value to the new document. See Insert Behavior.以下示例将新文档插入到inventory集合中。如果文档没有指定_id字段，则Motor驱动程序会将具有ObjectId值的_id字段添加到新文档中。请参见插入行为。

Collection.insertOne() inserts a single document into a collection.将单个文档插入到集合中。

The following example inserts a new document into the inventory collection. If the document does not specify an _id field, the Node.js driver adds the _id field with an ObjectId value to the new document. 以下示例将新文档插入到inventory集合中。如果文档没有指定_id字段，Node.js驱动程序会将具有ObjectId值的_id字段添加到新文档中。See Insert Behavior.请参见插入行为。

MongoDB\\Collection::insertOne() inserts a single document into a collection.将单个文档插入到集合中。

The following example inserts a new document into the inventory collection. If the document does not specify an _id field, the PHP driver adds the _id field with an ObjectId value to the new document. See Insert Behavior.以下示例将新文档插入到inventory集合中。如果文档没有指定_id字段，PHP驱动程序会将具有ObjectId值的_id字段添加到新文档中。请参见插入行为。

pymongo.collection.Collection.insert_one inserts a single document into a collection.将单个文档插入到集合中。

The following example inserts a new document into the inventory collection. If the document does not specify an _id field, the PyMongo driver adds the _id field with an ObjectId value to the new document. See Insert Behavior.以下示例将新文档插入到inventory集合中。如果文档没有指定_id字段，PyMongo驱动程序会将具有ObjectId值的_id字段添加到新文档中。请参见插入行为。

Mongo::Collection#insert_one() inserts a single document into a collection.将单个文档插入到集合中。

The following example inserts a new document into the inventory collection. 以下示例将新文档插入到inventory集合中。If the document does not specify an _id field, the Ruby driver adds the _id field with an ObjectId value to the new document. 如果文档没有指定_id字段，Ruby驱动程序会将具有ObjectId值的_id字段添加到新文档中。See Insert Behavior.请参见插入行为。

collection.insertOne() inserts a single document into a collection.将单个文档插入到集合中。

The following example inserts a new document into the inventory collection. 以下示例将新文档插入到inventory集合中。If the document does not specify an _id field, the Scala driver adds the _id field with an ObjectId value to the new document. 如果文档没有指定_id字段，Scala驱动程序会将具有ObjectId值的_id字段添加到新文档中。See Insert Behavior.请参见插入行为。

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

$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() returns a document that includes the newly inserted document's _id field value. For an example of a return document, see db.collection.insertOne() reference.返回一个包含新插入文档的_id字段值的文档。有关返回文档的示例，请参阅db.collection.insertOne()参考。

To retrieve the document that you just inserted, query the collection by specifying a filter in the MongoDB Compass query bar and clicking Find to execute the query.要检索您刚才插入的文档，请在MongoDB Compass查询栏中指定一个筛选器并单击“查找”以执行查询，从而查询集合。

The following filter specifies that MongoDB Compass only return documents where the item field is equal to canvas. 以下筛选器指定MongoDB Compass仅返回item字段等于canvas的文档。For more information on the MongoDB Compass Query Bar, see Query Bar.有关MongoDB Compass查询栏的更多信息，请参阅查询栏。

mongoc_collection_insert_one returns true if successful, or returns false and sets error if there are invalid arguments or a server or network error.如果成功，则返回true；如果存在无效参数或服务器或网络错误，则返回false并设置错误。

To retrieve the document that you just inserted, query the collection:要检索您刚才插入的文档，请查询集合：

To retrieve the document that you just inserted, query the collection:

Collection.InsertOne function returns an instance of InsertOneResult whose InsertedID attribute contains the _id of the newly inserted document.函数返回InsertOneResult的实例，其InsertedID属性包含新插入文档的_id。

To retrieve the document that you just inserted, query the collection:要检索您刚才插入的文档，请查询集合：

com.mongodb.reactivestreams.client.MongoCollection.insertOne returns a Publisher object. The Publisher inserts the document into a collection when subscribers request data.返回Publisher对象。当订阅者请求数据时，Publisher会将文档插入到集合中。

To retrieve the document that you just inserted, query the collection:要检索您刚才插入的文档，请查询集合：

com.mongodb.client.MongoCollection.insertOne returns an instance of InsertOneResult. 返回InsertOneResult的实例。You can access the _id field of the inserted document by calling the getInsertedId() method on the result.您可以通过对结果调用getInsertedId()方法来访问插入文档的_id字段。

To retrieve the document that you just inserted, query the collection:要检索您刚才插入的文档，请查询集合：

MongoCollection.insertOne returns an instance of InsertOneResult. 返回InsertOneResult的实例。You can access the _id field of the inserted document by accessing the insertedId field of the result.您可以通过访问结果的insertedId字段来访问插入文档的_id字段。

To retrieve the document that you just inserted, query the collection:要检索您刚才插入的文档，请查询集合：

insert_one returns an instance of pymongo.results.InsertOneResult whose inserted_id field contains the _id of the newly inserted document.返回pymongo.results.InsertOneResult的实例，其inserted_id字段包含新插入文档的_id。

To retrieve the document that you just inserted, query the collection:要检索您刚才插入的文档，请查询集合：

insertOne() returns a promise that provides a result. The result.insertedId promise contains the _id of the newly inserted document.返回一个提供result的promise。result.insertedId promise包含新插入文档的_id。

To retrieve the document that you just inserted, query the collection:要检索您刚才插入的文档，请查询集合：

Upon successful insert, the insertOne() method returns an instance of MongoDB\\InsertOneResult whose getInsertedId() method returns the _id of the newly inserted document.插入成功后，insertOne()方法返回MongoDB\\InsertOneResult的一个实例，其getInsertedId()方法将返回新插入文档的_id。

To retrieve the document that you just inserted, query the collection:要检索您刚才插入的文档，请查询集合：

insert_one returns an instance of pymongo.results.InsertOneResult whose inserted_id field contains the _id of the newly inserted document.返回pymongo.results.InsertOneResult的实例，其inserted_id字段包含新插入文档的_id。

To retrieve the document that you just inserted, query the collection:要检索您刚才插入的文档，请查询集合：

Upon successful insert, the insert_one() method returns an instance of Mongo::Operation::Result, whose inserted_id attribute contains the _id of the newly inserted document.插入成功后，insert_one()方法返回Mongo::Operation::Result的实例，其inserted_id属性包含新插入文档的_id。

To retrieve the document that you just inserted, query the collection:要检索您刚才插入的文档，请查询集合：

Upon successful insert, the collection.insertOne() method returns an instance of collection.insertOne().results(); whose inserted_id attribute contains the _id of the newly inserted document.成功插入后，collection.insertOne()方法返回collection.insertOne().results();的实例；其inserted_id属性包含新插入文档的_id。

To retrieve the document that you just inserted, query the collection:要检索您刚才插入的文档，请查询集合：

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

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->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() can insert multiple documents into a collection. Pass an array of documents to the method.可以将多个文档插入到集合中。将一组文档传递给该方法。

The following example inserts three new documents into the inventory collection. If the documents do not specify an _id field, MongoDB adds the _id field with an ObjectId value to each document. 以下示例将三个新文档插入到inventory集合中。如果文档没有指定_id字段，MongoDB会将具有ObjectId值的_id字段添加到每个文档中。See Insert Behavior.请参见插入行为。

For instructions on inserting documents using MongoDB Compass, see Insert Documents. You can paste the following documents into the Insert Document dialog in Compass to insert multiple item documents into the inventory collection:有关使用MongoDB Compass插入文档的说明，请参阅插入文档。您可以将以下文档粘贴到Compass中的“插入文档”对话框中，以将多个项目文档插入到inventory集合中：

mongoc_bulk_operation_insert_with_opts inserts multiple documents into a collection. You must pass an iterable of documents to the method.将多个文档插入到集合中。您必须将文档的可迭代对象传递给该方法。

The following example inserts three new documents into the inventory collection. If the documents do not specify an _id field, the C driver adds the _id field with an ObjectId value to each document. 以下示例将三个新文档插入到inventory集合中。如果文档没有指定_id字段，C驱动程序会将具有ObjectId值的_id字段添加到每个文档中。See Insert Behavior.请参见插入行为。

IMongoCollection.InsertMany() can insert multiple documents into a collection. Pass an enumerable collection of documents to the method.可以将多个文档插入到集合中。将可枚举的文档集合传递给该方法。

The following example inserts three new documents into the inventory collection. If the documents do not specify an _id field, the driver adds the _id field with an ObjectId value to each document. See Insert Behavior.以下示例将三个新文档插入到inventory集合中。如果文档没有指定_id字段，则驱动程序会将具有ObjectId值的_id字段添加到每个文档中。请参见插入行为。

Collection.InsertMany can insert multiple documents into a collection.可以将多个文档插入到集合中。

The following example inserts three new documents into the inventory collection. 以下示例将三个新文档插入到inventory集合中。If the documents do not specify an _id field, the driver adds the _id field with an ObjectId value to each document. 如果文档没有指定_id字段，则驱动程序会将具有ObjectId值的_id字段添加到每个文档中。See Insert Behavior.请参见插入行为。

com.mongodb.reactivestreams.client.MongoCollection.html.insertMany inserts the following documents with the Java Reactive Streams Driver:使用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" } }

The following example inserts three new documents into the inventory collection. 以下示例将三个新文档插入到inventory集合中。If the documents do not specify an _id field, the driver adds the _id field with an ObjectId value to each document. 如果文档没有指定_id字段，则驱动程序会将具有ObjectId值的_id字段添加到每个文档中。See Insert Behavior.请参见插入行为。

com.mongodb.client.MongoCollection.insertMany can insert multiple documents into a collection. Pass a list of documents to the method.可以将多个文档插入到集合中。将文档列表传递给该方法。

The following example inserts three new documents into the inventory collection. 以下示例将三个新文档插入到inventory集合中。If the documents do not specify an _id field, the driver adds the _id field with an ObjectId value to each document. 如果文档没有指定_id字段，则驱动程序会将具有ObjectId值的_id字段添加到每个文档中。See Insert Behavior.请参见插入行为。

MongoCollection.insertMany inserts multiple documents into a collection. Pass a list of documents as a parameter to the method.将多个文档插入到集合中。将文档列表作为参数传递给该方法。

The following example inserts three new documents into the inventory collection. If the documents do not specify an _id field, the driver adds an ObjectId value to each document. See Insert Behavior.以下示例将三个新文档插入到inventory集合中。如果文档没有指定_id字段，驱动程序会向每个文档添加一个ObjectId值。请参见插入行为。

motor.motor_asyncio.AsyncIOMotorCollection.insert_many can insert multiple documents into a collection. Pass an iterable of documents to the method.可以将多个文档插入到集合中。将文档的可迭代对象传递给该方法。

The following example inserts three new documents into the inventory collection. If the documents do not specify an _id field, the PyMongo driver adds the _id field with an ObjectId value to each document. 以下示例将三个新文档插入到inventory集合中。如果文档没有指定_id字段，PyMongo驱动程序会将具有ObjectId值的_id字段添加到每个文档中。See Insert Behavior.请参见插入行为。

Collection.insertMany() can insert multiple documents into a collection. Pass an array of documents to the method.可以将多个文档插入到集合中。将一组文档传递给该方法。

The following example inserts three new documents into the inventory collection. If the documents do not specify an _id field, the Node.js driver adds the _id field with an ObjectId value to each document. See Insert Behavior.以下示例将三个新文档插入到inventory集合中。如果文档没有指定_id字段，Node.js驱动程序会将具有ObjectId值的_id字段添加到每个文档中。请参见插入行为。

MongoDB\\Collection::insertMany() can insert multiple documents into a collection. Pass an array of documents to the method.可以将多个文档插入到集合中。将一组文档传递给该方法。

The following example inserts three new documents into the inventory collection. If the documents do not specify an _id field, the PHP driver adds the _id field with an ObjectId value to each document. 以下示例将三个新文档插入到inventory集合中。如果文档没有指定_id字段，PHP驱动程序会将具有ObjectId值的_id字段添加到每个文档中。See Insert Behavior.请参见插入行为。

pymongo.collection.Collection.insert_many can insert multiple documents into a collection. Pass an iterable of documents to the method.可以将多个文档插入到集合中。将文档的可迭代对象传递给该方法。

The following example inserts three new documents into the inventory collection. If the documents do not specify an _id field, the PyMongo driver adds the _id field with an ObjectId value to each document. 以下示例将三个新文档插入到inventory集合中。如果文档没有指定_id字段，PyMongo驱动程序会将具有ObjectId值的_id字段添加到每个文档中。See Insert Behavior.请参见插入行为。

Mongo::Collection#insert_many() can insert multiple documents into a collection. Pass an array of documents to the method.可以将多个文档插入到集合中。将一组文档传递给该方法。

The following example inserts three new documents into the inventory collection. If the documents do not specify an _id field, the Ruby driver adds the _id field with an ObjectId value to each document. 以下示例将三个新文档插入到inventory集合中。如果文档没有指定_id字段，Ruby驱动程序会将具有ObjectId值的_id字段添加到每个文档中。See Insert Behavior.请参见插入行为。

collection.insertMany() can insert multiple documents into a collection.可以将多个文档插入到集合中。

The following example inserts three new documents into the inventory collection. 以下示例将三个新文档插入到inventory集合中。If the documents do not specify an _id field, the Scala driver adds the _id field with an ObjectId value to each document. 如果文档没有指定_id字段，Scala驱动程序会将具有ObjectId值的_id字段添加到每个文档中。See Insert Behavior.请参见插入行为。

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" }
]

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(),
	[]any{
		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' }
  }
]);

$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() returns a document that includes the newly inserted documents _id field values. 返回一个包含新插入的文档_id字段值的文档。See the reference for an example.请参阅参考资料中的示例。

To retrieve the inserted documents, query the collection:要检索插入的文档，请查询集合：

To view the newly inserted documents, specify a filter of {} in the MongoDB Compass query bar and click Find to view your documents.要查看新插入的文档，请在MongoDB Compass查询栏中指定{}筛选器，然后单击“查找”以查看您的文档。

mongoc_bulk_operation_insert_with_opts returns true on success, or false if passed invalid arguments.成功时返回true，传递无效参数时返回false。

To retrieve the inserted documents, use mongoc_collection_find_with_opts to query the collection:要检索插入的文档，请使用mongoc_collection_find_with_opts查询集合：

To retrieve the inserted documents, query the collection:要检索插入的文档，请查询集合：

To retrieve the inserted documents, query the collection:

com.mongodb.reactivestreams.client.MongoCollection.html.insertMany returns a Publisher object. 返回Publisher对象。The Publisher inserts the document into a collection when subscribers request data.当订阅者请求数据时，Publisher会将文档插入到集合中。

To retrieve the inserted documents, query the collection:要检索插入的文档，请查询集合：

To retrieve the inserted documents, query the collection:要检索插入的文档，请查询集合：

MongoCollection.insertMany() returns an InsertManyResult instance. The insertedIds field of InsertManyResult contains the _id values of the inserted documents.返回InsertManyResult实例。InsertManyResult的insertedIds字段包含插入文档的_id值。

To retrieve the inserted documents, query the collection:要检索插入的文档，请查询集合：

insert_many returns an instance of pymongo.results.InsertManyResult whose inserted_ids field is a list containing the _id of each newly inserted document.返回pymongo.results.InsertManyResult的实例，其inserted_ids字段是一个包含每个新插入文档的_id的列表。

To retrieve the inserted documents, query the collection:要检索插入的文档，请查询集合：

insertMany() returns a promise that provides a result. 返回一个提供result的promise。The result.insertedIds field contains an array with the _id of each newly inserted document.result.insertedIds字段包含一个数组，其中包含每个新插入文档的_id。

To retrieve the inserted documents, query the collection:要检索插入的文档，请查询集合：

Upon successful insert, the insertMany() method returns an instance of MongoDB\\InsertManyResult whose getInsertedIds() method returns the _id of each newly inserted document.方法返回一个MongoDB\\InsertManyResult的实例，其getInsertedIds()方法返回每个新插入文档的_id。

To retrieve the inserted documents, query the collection:要检索插入的文档，请查询集合：

insert_many returns an instance of pymongo.results.InsertManyResult whose inserted_ids field is a list containing the _id of each newly inserted document.返回pymongo.results.InsertManyResult的实例，其inserted_ids字段是一个包含每个新插入文档的_id的列表。

To retrieve the inserted documents, query the collection:要检索插入的文档，请查询集合：

Upon successful insert, the insert_many() method returns an instance of Mongo::BulkWrite::Result whose inserted_ids attribute is a list containing the _id of each newly inserted document.插入成功后，insert_many()方法返回Mongo::BulkWrite::Result的一个实例，其inserted_ids属性是一个包含每个新插入文档的_id的列表。

To retrieve the inserted documents, query the collection:要检索插入的文档，请查询集合：

Upon successful insert, the insertMany() method returns an Observable with a type parameter indicating when the operation has completed or with either a com.mongodb.DuplicateKeyException or com.mongodb.MongoException.插入成功后，insertMany()方法返回一个Observable，该Observable具有一个类型参数，指示操作何时完成，或者返回一个com.mongodb.DuplicateKeyException或com.mongodb.MongoException。

To retrieve the inserted documents, query the collection:要检索插入的文档，请查询集合：

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

Be sure to also clean up any open resources by calling the following methods, as appropriate:请确保根据需要调用以下方法来清理任何开放资源：

• bson_destroy
• mongoc_bulk_operation_destroy
• mongoc_collection_destroy
• mongoc_cursor_destroy,

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->inventory->find([]);

cursor = db.inventory.find({})

client[:inventory].find({})

var findObservable = collection.find(Document())