Insira documentos

Nesta página

Inserir documentos na interface do usuário do MongoDB Atlas

Inserir um único documento
Insira vários documentos
Inserir comportamento

➤ Use o menu suspenso Selecione a linguagem no canto superior direito para definir a linguagem dos exemplos a seguir ou selecione MongoDB Compass.

Esta página fornece exemplos de operações de inserção no MongoDB.

Você pode inserir documentos no MongoDB usando os métodos:

O driver da sua linguagem de programação.
O MongoDB Atlas IU. Para saber mais, consulte Inserir documentos na IU do MongoDB Atlas.
MongoDB Compass.

Observação

Criar uma collection

Se a coleta não existir atualmente, as operações de inserção criarão a coleta.

Inserir documentos na interface do usuário do MongoDB Atlas

Para inserir um documento na IU do MongoDB Atlas, complete as etapas a seguir. Para saber mais sobre como trabalhar com documentos na IU do MongoDB Atlas, consulte Criar, exibir, atualizar e excluir documentos.

Na interface do usuário do MongoDB Atlas, vá para a página Clusters do seu projeto.

Se ainda não estiver exibido, selecione a organização que contém o projeto desejado no menu Organizations na barra de navegação.
Se ainda não estiver exibido, selecione seu projeto no menu Projects na barra de navegação.
Se a página Clusters ainda não estiver exibida, clique em Database na barra lateral.
A página Clusters é exibida.

Navegue até a coleção

Para o cluster ao qual você deseja adicionar documentos, clique em Browse Collections.
No painel de navegação esquerdo, selecione o banco de dados.
No painel de navegação esquerdo, selecione a coleção.

Adicionar os documentos

Clique em Insert Document.
Clique no ícone {} , que abre a visualização JSON.

Cole a array de documentos no campo de entrada de texto. Por exemplo, a entrada a seguir cria quatro documentos, cada um dos quais contém três campos:

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

Clique em Inserir.

O Atlas do MongoDB adiciona os documentos à collection.

Inserir um único documento

db.collection.insertOne() insere um documento único em uma coleção.

O exemplo a seguir insere um novo documento na inventory coleção. Se o documento não especificar um campo _id, o MongoDB adicionará o campo _id com um valor ObjectId ao novo documento. Consulte Inserir comportamento.

Para inserir um único documento usando MongoDB Compass:

Navegue até a coleção na qual deseja inserir o documento:
1. No painel de navegação esquerdo do MongoDB Compass, clique no banco de dados ao qual sua coleção de destino pertence.
2. Na visualização do banco de dados, clique no nome da coleção de destino.
Clique no botão Insert Document:
Para cada campo do documento, selecione o tipo de campo e preencha o nome e o valor do campo. Adicione campos clicando no número da última linha e, em seguida, em Add Field After ...
- Para tipos Object, adicione campos aninhados clicando no número do último campo e selecionando Add Field After ...
- Para Array tipos, adicione elementos adicionais à matriz clicando no número de linha do último elemento e selecionando Add Array Element After ...
Depois que todos os campos forem preenchidos, clique em Insert.

O exemplo a seguir insere um novo documento na coleção test.inventory:

O exemplo a seguir insere um novo documento na collection inventory . Se o documento não especificar um campo _id , o driver C adicionará o campo _id com um valor ObjectId ao novo documento. Para mais informações, consulte Inserir comportamento.

IMongoCollection.InsertOne() insere um único documento em uma coleção.

O exemplo a seguir insere um novo documento na coleção inventory. Se o documento não especificar um campo _id, o driver C# adicionará o campo _id com um valor ObjectId ao novo documento. Consulte Inserir comportamento.

Collection.insertOne() insere um documento único em uma coleção.

O exemplo a seguir insere um novo documento na collection inventory . Se o documento não especificar um campo _id , o driver adicionará o campo _id com um valor ObjectId ao novo documento. Consulte Inserir comportamento.

com.mongodb.reactivestreams.client.MongoCollection.insertOne insere um único documento em uma coleção com o Java Reactive Streams Driver:

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

O exemplo a seguir insere o documento acima na coleção inventory. Se o documento não especificar um campo _id, o driver adicionará o campo _id com um valor ObjectId ao novo documento. Consulte Inserir comportamento.

com.mongodb.client.MongoCollection.insertOne insere um documento único em uma collection.

MongoCollection.insertOne insere um documento único em uma collection.

motor.motor_asyncio.AsyncIOMotorCollection.insert_one insere um documento único em uma coleção.

O exemplo a seguir insere um novo documento na coleção inventory. Se o documento não especificar um campo _id, o driver Motor adicionará o campo _id com um valor ObjectId ao novo documento. Consulte Inserir comportamento.

Collection.insertOne() insere um documento único em uma coleção.

O exemplo a seguir insere um novo documento na coleção inventory . Se o documento não especificar um campo _id, o driver Node.js adicionará o campo _id com um valor ObjectId ao novo documento. Consulte Inserir comportamento.

MongoDB::Collection::insert_one() insere um único documento em uma coleção.

O exemplo a seguir insere um novo documento na coleção inventory. Se o documento não especificar um campo _id, o driver Perl adicionará o campo _id com um valor ObjectId ao novo documento. Consulte Inserir comportamento.

MongoDB\\Collection::insertOne() insere um único documento em uma coleção.

O exemplo a seguir insere um novo documento na coleção inventory. Se o documento não especificar um campo _id, o driver PHP adicionará o campo _id com um valor ObjectId ao novo documento. Consulte Inserir comportamento.

pymongo.collection.Collection.insert_one insere um documento único em uma coleção.

O exemplo a seguir insere um novo documento na coleção inventory. Se o documento não especificar um campo _id, o driver PyMongo adicionará o campo _id com um valor ObjectId ao novo documento. Consulte Inserir comportamento.

Mongo::Collection#insert_one() insere um único documento em uma coleção.

O exemplo a seguir insere um novo documento na coleção inventory. Se o documento não especificar um campo _id, o driver Ruby adicionará o campo _id com um valor ObjectId ao novo documento. Consulte Inserir comportamento.

Collection.insertOne() insere um documento único em uma coleção.

O exemplo a seguir insere um novo documento na coleção inventory. Se o documento não especificar um campo _id, o driver Scala adicionará o campo _id com um valor ObjectId ao novo documento. Consulte Inserir comportamento.

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

O Compass insere um novo documento em uma coleção

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() retorna um documento que inclui o valor de campo _id do documento recém-inserido. Para obter um exemplo de um documento de retorno, consulte a referência db.collection.insertOne().

Observação

O MongoDB Compass gera o campo _id e seu valor automaticamente. O ObjectID gerado consiste em um valor hexadecimal exclusivo gerado aleatoriamente.

Você pode alterar esse valor antes de inserir o documento, desde que ele permaneça exclusivo e seja um ObjectIdválido. Para obter mais informações sobre o campo _id, consulte Campo _id.

mongoc_collection_insert_one retorna true se for bem-sucedido ou retorna false e define um erro se houver argumentos inválidos ou um erro de servidor ou rede.

A função Collection.InsertOne retorna uma instância de InsertOneResult cujo InsertedID atributo contém o _id do documento recém-inserido.

com.mongodb.reactivestreams. cliente.MongoCollection.insertOne retorna um editor objeto. O Publisher insere o documento em uma collection quando os assinantes solicitam dados.

com.mongodb.client.MongoCollection.insertOne retorna uma instância de InsertOneResult. Você pode acessar o _id campo do documento inserido chamando o getInsertedId() método no resultado.

MongoCollection.insertOne retorna uma instância de InsertOneResult. Você pode acessar o campo _id do documento inserido acessando o campo insertedId do resultado.

A função insert_one retorna uma instância de pymongo.results.InsertOneResult cujo campo inserted_id contém o _id do documento recém-inserido.

insertOne() retorna uma promessa que fornece um result. A promessa result.insertedId contém o _id do documento recém-inserido.

Após a inserção bem-sucedida, o insert_one() método retorna uma instância de MongoDB::InsertOneResult cujo inserted_id atributo contém o _id do documento recém-inserido.

Após a inserção bem-sucedida, o método insertOne() retorna uma instância de MongoDB\\InsertOneResult cujo método getInsertedId() retorna o _id do documento recém-inserido.

A função insert_one retorna uma instância de pymongo.results.InsertOneResult cujo campo inserted_id contém o _id do documento recém-inserido.

Após a inserção bem-sucedida, o método insert_one() retorna uma instância de Mongo::Operation::Result, cujo atributo inserted_id contém o _id do documento recém-inserido.

Após a inserção bem-sucedida, o método collection.insertOne() retorna uma instância de collection.insertOne () .results (); cujo atributo inserted_id contém o _id do documento recém-inserido.

Para recuperar o documento que você acabou de inserir, consulte a collection:

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

Query de documentos correspondentes em uma coleção

Especifique um filtro na barra de consulta do MongoDB Compass e clique em Find para executar a consulta.

O filtro acima especifica que o MongoDB Compass retorna somente documentos onde o campo item é igual a canvas.

Para obter mais informações sobre o MongoDB Compass Query Bar, consulte a documentação do Compass Query Bar .

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

Insira vários documentos

db.collection.insertMany() pode inserir vários documentos em uma collection. Passe uma array de documentos para o método.

O exemplo a seguir insere três novos documentos na coleção inventory. Se os documentos não especificarem um campo _id, o MongoDB adicionará o campo _id com um valor ObjectId a cada documento. Consulte Inserir comportamento.

mongoc_bulk_operation_insert_with_opts insere vários documentos em uma collection. Você deve passar um iterável de documentos para o método.

O exemplo a seguir insere três novos documentos na collection inventory . Se os documentos não especificarem um campo _id , o driver C adicionará o campo _id com um valor ObjectId a cada documento. Consulte Inserir comportamento.

IMongoCollection.InsertMany() pode inserir vários documentos em uma coleção. Passe uma coleção enumerável de documentos para o método.

O exemplo a seguir insere três novos documentos na coleção inventory. Se os documentos não especificarem um campo _id, o driver adicionará o campo _id com um valor ObjectId a cada documento. Consulte Inserir comportamento.

Collection.insertMany() pode inserir múltiplos documentos em uma coleção.

com.mongodb.reactivestreams.client.MongoCollection.html.insertMany insere os seguintes documentos com o Java Reactive Streams Driver:

{ 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 pode inserir vários documentos em uma collection. Passe uma lista de documentos para o método.

MongoCollection.insertMany insere vários documentos em uma collection. Passe uma lista de documentos como parâmetro para o método.

O exemplo a seguir insere três novos documentos na collection inventory . Se os documentos não especificarem um campo _id , o driver adicionará um valor ObjectId a cada documento. Consulte Inserir comportamento.

motor.motor_asyncio.AsyncIOMotorCollection.insert_many pode inserir vários documentos em uma coleção. Passe um iterável de documentos para o método.

O exemplo a seguir insere três novos documentos na coleção inventory. Se os documentos não especificarem um campo _id, o driver PyMongo adicionará o campo _id com um valor ObjectId a cada documento. Consulte Inserir comportamento.

Collection.insertMany() pode inserir múltiplos documentos em uma coleção. Passe um array de documentos para o método.

O exemplo a seguir insere três novos documentos na coleção inventory. Se os documentos não especificarem um campo _id, o driver Node.js adicionará o campo _id com um valor ObjectId a cada documento. Consulte Inserir comportamento.

MongoDB::Collection::insert_many() pode inserir vários documentos em uma coleção. Passe uma referência de array de documentos para o método.

O exemplo a seguir insere três novos documentos na coleção inventory. Se os documentos não especificarem um campo _id, o driver Perl adicionará o campo _id com um valor ObjectId a cada documento. Consulte Inserir comportamento.

MongoDB\\Collection::insertMany() pode inserir vários documentos em uma coleção. Passe um array de documentos para o método.

O exemplo a seguir insere três novos documentos na coleção inventory. Se os documentos não especificarem um campo _id, o driver PHP adicionará o campo _id com um valor ObjectId a cada documento. Consulte Inserir comportamento.

pymongo.collection.Collection.insert_many pode inserir vários documentos em uma coleção. Passe um iterável de documentos para o método.

Mongo::Collection#insert_many() pode inserir vários documentos em uma coleção. Passe um array de documentos para o método.

O exemplo a seguir insere três novos documentos na coleção inventory. Se os documentos não especificarem um campo _id, o driver Ruby adicionará o campo _id com um valor ObjectId a cada documento. Consulte Inserir comportamento.

Collection.insertMany() pode inserir múltiplos documentos em uma coleção.

O exemplo a seguir insere três novos documentos na coleção inventory. Se os documentos não especificarem um campo _id, o driver Scala adicionará o campo _id com um valor ObjectId a cada documento. Consulte Inserir comportamento.

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

Para obter instruções sobre como inserir documentos usando o MongoDB Compass, consulte Inserir documentos.

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() retorna um documento que inclui o valor de campo _id do documento recém-inserido. Veja a referência para obter um exemplo.