➤ Use el menú desplegable Seleccionar su lenguaje en la parte superior derecha para establecer el lenguaje de los siguientes ejemplos o seleccione MongoDB Compass.
Esta página ofrece ejemplos de operaciones de inserción en MongoDB.
Puede insertar documentos en MongoDB utilizando los siguientes métodos:
El driver de su lenguaje de programación.
La Interfaz de Usuario de MongoDB Atlas. Para aprender más, consulta Insertar documentos en la Interfaz de Usuario de MongoDB Atlas.
Nota
Creación de una colección
Si la colección no existe actualmente, las operaciones de inserción crearán la colección.
Insertar documentos en la interfaz de usuario de MongoDB Atlas
Para insertar un documento en la interfaz de usuario de MongoDB Atlas, complete los siguientes pasos. Para aprender más sobre cómo trabajar con documentos en la Interfaz de Usuario de MongoDB Atlas, consulte Crear, ver, actualizar y borrar documentos.
En la interfaz de usuario de MongoDB Atlas, vaya a Clusters Página para su proyecto.
Si aún no se muestra, seleccione la organización que contiene su proyecto deseado en el menú Organizations de la barra de navegación.
Si aún no se muestra, seleccione su proyecto en el menú Projects de la barra de navegación.
En la barra lateral, haz clic en Clusters en la sección Database.
La página de clústeres se muestra.
Agregue los documentos
Haga clic en Insert Document.
Haga clic en el icono {}, el cual abre la vista JSON.
Pegue el arreglo del documento en el campo de entrada de texto. Por ejemplo, la siguiente entrada crea cuatro documentos, cada uno de los cuales contiene tres 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 } ]
Inserta un solo documento
db.collection.insertOne()inserta un solo documento en una colección.
El siguiente ejemplo inserta un nuevo documento en la colección inventory. Si el documento no especifica un campo _id, MongoDB agrega el campo _id con un valor de tipo ObjectId al nuevo documento. Consulta Insertar comportamiento.
Para insertar un solo documento con MongoDB Compass:
Navegue hasta la colección en la que desea insertar el documento:
En el panel de navegación izquierdo de MongoDB Compass, haga clic en la base de datos a la que pertenece su colección de destino.
Desde la vista de la base de datos, haga clic en el nombre de la colección objetivo.
Haga clic en el botón Insert Document:
![Botón de inserción de Compass]()
Para cada campo del documento, seleccione el tipo de campo y complete el nombre y el valor del campo. Agregue campos haciendo clic en el último número de línea y luego en Add Field After ...
Para los tipos
Object, agregue campos anidados haciendo clic en el número del último campo y seleccionando Add Field After ...Para los tipos
Array, agregue elementos adicionales a la matriz haciendo clic en el número de línea del último elemento y seleccionando Add Array Element After ...
Una vez que se hayan completado todos los campos, haga clic en Insert.
El siguiente ejemplo inserta un nuevo documento en la colección test.inventory:
IMongoCollection.InsertOne()inserta un solo documento en una colección.
El siguiente ejemplo inserta un nuevo documento en la colección inventory. Si el documento no especifica un campo _id, el driver C# agrega el campo _id con un valor de tipo ObjectId al nuevo documento. Consulta Insertar comportamiento.
Collection.InsertOne inserta un único documento en una colección.
El siguiente ejemplo inserta un nuevo documento en la colección inventory. Si el documento no especifica un campo _id, el driver agrega el campo _id con un valor de tipo ObjectId al nuevo documento. Consulta Insertar comportamiento.
com.mongodb.reactivestreams.client.MongoCollection.insertOne inserta un único documento en una colección con el Java Reactive Streams Driver:
{ item: "canvas", qty: 100, tags: ["cotton"], size: { h: 28, w: 35.5, uom: "cm" } }
El siguiente ejemplo inserta el documento anterior en la colección inventory. Si el documento no especifica un campo _id, el driver agrega el campo _id con un valor de tipo ObjectId al nuevo documento. Consulta Insertar comportamiento.
com.mongodb.client.MongoCollection.insertOne inserta un único documento en una colección.
El siguiente ejemplo inserta un nuevo documento en la colección inventory. Si el documento no especifica un campo _id, el driver agrega el campo _id con un valor de tipo ObjectId al nuevo documento. Consulta Insertar comportamiento.
motor.motor_asyncio.AsyncIOMotorCollection.insert_one inserta un único documento en una colección.
El siguiente ejemplo inserta un nuevo documento en la colección inventory. Si el documento no especifica un campo _id, el driver Motor agrega el campo _id con un valor de tipo ObjectId al nuevo documento. Consulta Insertar comportamiento.
Collection.insertOne() inserta un único documento en una colección.
El siguiente ejemplo inserta un nuevo documento en la colección inventory. Si el documento no especifica un campo _id, el driver de Node.js agrega el campo _id con un valor ObjectId al nuevo documento. Consulta Insertar comportamiento.
MongoDB::Collection::insert_one() inserta un solo documento en una colección.
El siguiente ejemplo inserta un nuevo documento en la inventory colección. Si el documento no especifica un _id campo, el controlador de Perl añade el _id campo con un valor ObjectId al nuevo documento.Consulte Comportamiento de inserción.
MongoDB\\Collection::insertOne() inserta un único documento en una colección.
El siguiente ejemplo inserta un nuevo documento en la colección inventory. Si el documento no especifica un campo _id, el driver PHP agrega el campo _id con un valor de tipo ObjectId al nuevo documento. Consulta Insertar comportamiento.
pymongo.collection.Collection.insert_one inserta un único documento en una colección.
En el siguiente ejemplo, se inserta un nuevo documento en la colección inventory. Si el documento no especifica un campo _id, el driver PyMongo agrega el campo _id con un valor ObjectId al nuevo documento. Consulta Inserta un comportamiento.
Mongo::Collection#insert_one() inserta un único documento en una colección.
El siguiente ejemplo inserta un nuevo documento en la colección inventory. Si el documento no especifica un campo _id, el driver Ruby agrega el campo _id con un valor de tipo ObjectId al nuevo documento. Consulta Insertar comportamiento.
collection.insertOne() inserta un único documento en una colección.
El siguiente ejemplo inserta un nuevo documento en la colección inventory. Si el documento no especifica un campo _id, el driver de Scala agrega el campo _id con un valor de tipo ObjectId al nuevo documento. Consulta Insertar comportamiento.
db.inventory.insertOne( { item: "canvas", qty: 100, tags: ["cotton"], size: { h: 28, w: 35.5, uom: "cm" } } )
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);
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() devuelve un documento que incluye el valor del campo _id del documento recién insertado. Para un ejemplo de un documento de retorno, consulta la referencia db.colección.insertOne().
Nota
MongoDB Compass genera el campo _id y su valor automáticamente. El ObjectId generado consiste en un valor hexadecimal único generado aleatoriamente.
Se puede cambiar este valor antes de insertar el documento, siempre que siga siendo único y sea un ObjectId válido. Para obtener más información sobre el campo _id, se debe consultar Campo _id.
La función Collection.InsertOne devuelve una instancia de InsertOneResult cuyo atributo InsertedID contiene el _id del documento recién insertado.
com.mongodb.client.MongoCollection.insertOne devuelve una instancia de InsertOneResult. Puede acceder al campo _id del documento insertado llamando al método getInsertedId() en el resultado.
insert_one devuelve una instancia de pymongo.results.InsertOneResult cuyo campo inserted_id contiene el _id del documento recién insertado.
insertOne() devuelve una promesa que proporciona un result. La promesa result.insertedId contiene el _id del documento recién insertado.
Tras una inserción exitosa, el método insert_one() devuelve una instancia de MongoDB::InsertOneResult cuyo inserted_id atributo contiene el _id del documento recién insertado.
Tras una inserción exitosa, el método insertOne() devuelve una instancia de MongoDB\\InsertOneResult cuyo método getInsertedId() devuelve el _id del documento recién insertado.
insert_one devuelve una instancia de pymongo.results.InsertOneResult cuyo campo inserted_id contiene el _id del documento recién insertado.
Tras la inserción exitosa, el método insert_one() devuelve una instancia de Mongo::Operation::Result, cuyo atributo inserted_id contiene el _id del documento recién insertado.
Al realizar una inserción exitosa, el método collection.insertOne() devuelve una instancia de collection.insertOne().results(); cuyo atributo inserted_id contiene el _id del documento recién insertado.
Para recuperar el documento que acaba de insertar, query la colección:
db.inventory.find( { item: "canvas" } )
Especifique un filtro en la barra de consulta de MongoDB Compass y haga clic en Find para ejecutar la consulta.
El filtro anterior especifica que MongoDB Compass solo devuelve documentos donde el campo item es igual a canvas.
Para obtener más información sobre la barra de consultas Compass de MongoDB, consulte la documentación de la barra de consultas Compass.
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"));
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"))
Inserta varios documentos
➤ Usar el menú desplegable Seleccionar lenguaje en la parte superior derecha para establecer el lenguaje de los ejemplos en esta página.
Nuevo en la versión 3.2.
db.collection.insertMany() puede insertar múltiples documentos en una colección. Pase un arreglo de documentos al método.
El siguiente ejemplo inserta tres documentos nuevos en la colección inventory. Si los documentos no especifican un campo _id, MongoDB agrega el campo _id con un valor de tipo ObjectId a cada documento. Consulta Insertar comportamiento.
Nuevo en la versión 3.2.
IMongoCollection.InsertMany() puede insertar múltiples documentos en una colección. Pase una colección enumerada de documentos al método.
El siguiente ejemplo inserta tres documentos nuevos en la colección inventory. Si los documentos no especifican un campo _id, el driver agrega el campo _id con un valor de tipo ObjectId a cada documento. Vea Insertar comportamiento.
Collection.InsertMany puede insertar varios documentos en una colección.
El siguiente ejemplo inserta tres documentos nuevos en la colección inventory. Si los documentos no especifican un campo _id, el driver agrega el campo _id con un valor de tipo ObjectId a cada documento. Vea Insertar comportamiento.
Nuevo en la versión 3.2.
com.mongodb.reactivestreams.client.MongoCollection.html.insertMany inserta los siguientes documentos con el controlador de 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" } }
El siguiente ejemplo inserta tres documentos nuevos en la colección inventory. Si los documentos no especifican un campo _id, el driver agrega el campo _id con un valor de tipo ObjectId a cada documento. Vea Insertar comportamiento.
Nuevo en la versión 3.2.
com.mongodb.client.MongoCollection.insertMany puede insertar múltiples documentos en una colección. Pase una lista de documentos al método.
El siguiente ejemplo inserta tres documentos nuevos en la colección inventory. Si los documentos no especifican un campo _id, el driver agrega el campo _id con un valor de tipo ObjectId a cada documento. Vea Insertar comportamiento.
motor.motor_asyncio.AsyncIOMotorCollection.insert_many puede insertar múltiples documentos en una colección. Pase un iterable de documentos al método.
El siguiente ejemplo inserta tres documentos nuevos en la colección inventory. Si los documentos no especifican un campo _id, el driver PyMongo agrega el campo _id con un valor de tipo ObjectId a cada documento. Vea Insertar comportamiento.
Nuevo en la versión 3.2.
Collection.insertMany() puede insertar múltiples documentos en una colección. Pase un arreglo de documentos al método.
El siguiente ejemplo inserta tres documentos nuevos en la colección inventory. Si los documentos no especifican un campo _id, el driver Node.js agrega el campo _id con un valor de tipo ObjectId a cada documento. Consulta Insertar comportamiento.
Nuevo en la versión 3.2.
MongoDB::Collection::insert_many() permite insertar varios documentos en una colección. Pase una referencia de array de documentos al método.
El siguiente ejemplo inserta tres documentos nuevos en la inventory colección. Si los documentos no especifican un _id campo, el controlador de Perl añade el _id campo con un valor ObjectId a cada documento.Consulte Comportamiento de inserción.
MongoDB\\Collection::insertMany() puede insertar múltiples documentos en una colección. Pasa un arreglo de documentos al método.
El siguiente ejemplo inserta tres documentos nuevos en la colección inventory. Si los documentos no especifican un campo _id, el driver PHP agrega el campo _id con un valor de tipo ObjectId a cada documento. Consulta Insertar comportamiento.
Nuevo en la versión 3.2.
pymongo.collection.Collection.insert_many puede insertar múltiples documentos en una colección. Pase un iterable de documentos al método.
El siguiente ejemplo inserta tres documentos nuevos en la colección inventory. Si los documentos no especifican un campo _id, el driver PyMongo agrega el campo _id con un valor de tipo ObjectId a cada documento. Vea Insertar comportamiento.
Nuevo en la versión 3.2.
Mongo::Collection#insert_many() puede insertar múltiples documentos en una colección. Pasa un arreglo de documentos al método.
El siguiente ejemplo inserta tres documentos nuevos en la colección inventory. Si los documentos no especifican un campo _id, el driver Ruby agrega el campo _id con un valor de tipo ObjectId a cada documento. Vea Insertar comportamiento.
Nuevo en la versión 3.2.
collection.insertMany() puede insertar múltiples documentos en una colección.
El siguiente ejemplo inserta tres documentos nuevos en la colección inventory. Si los documentos no especifican un campo _id, el driver de Scala agrega el campo _id con un valor de tipo ObjectId a cada documento. Consulta Insertar comportamiento.
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 obtener instrucciones sobre cómo insertar documentos con MongoDB Compass, consulta Inserta documentos.
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));
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() devuelve un documento que incluye los valores del campo _id de los documentos recién insertados. Consulta la referencia para ver un ejemplo.
Para recuperar los documentos insertados, query la colección:
Para recuperar los documentos insertados, query la colección:
Para recuperar los documentos insertados, query la colección:
com.mongodb.reactivestreams.client.MongoCollection.html.insertMany devuelve un objeto Publisher. El Publisher inserta el documento en una colección cuando los suscriptores solicitan los datos.
Para recuperar los documentos insertados, query la colección:
Para recuperar los documentos insertados, query la colección:
insert_many devuelve una instancia de pymongo.results.InsertManyResult cuyo campo inserted_ids es una lista que contiene los _id de cada documento recién insertado.
Para recuperar los documentos insertados, query la colección:
insertMany() devuelve una promesa que proporciona un result. El campo result.insertedIds contiene un arreglo con los _id de cada documento recién insertado.
Para recuperar los documentos insertados, query la colección:
Tras una inserción exitosa, el método insert_many() devuelve una instancia de MongoDB::InsertManyResult cuyo inserted_ids atributo es una lista que contiene los _id de cada documento recién insertado.
Para recuperar los documentos insertados, query la colección:
Tras una inserción exitosa, el método insertMany() devuelve una instancia de MongoDB\\InsertManyResult cuyo método getInsertedIds() devuelve el _id de cada documento recién insertado.
Para recuperar los documentos insertados, query la colección:
insert_many devuelve una instancia de pymongo.results.InsertManyResult cuyo campo inserted_ids es una lista que contiene los _id de cada documento recién insertado.
Para recuperar los documentos insertados, query la colección:
Tras una inserción exitosa, el método insert_many() devuelve una instancia de Mongo::BulkWrite::Result cuyo atributo inserted_ids es una lista que contiene los _id de cada documento recién insertado.
Para recuperar los documentos insertados, query la colección:
Tras una inserción exitosa, el método insertMany() devuelve un Observable con un parámetro de tipo que indica cuándo se ha completado la operación o con un com.mongodb.DuplicateKeyException o com.mongodb.MongoException.
Para recuperar los documentos insertados, query la colección:
db.inventory.find( {} )
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());
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())
Insertar comportamiento
Creación de colección
Si la colección no existe actualmente, las operaciones de inserción crearán la colección.
_id Campo
En MongoDB, cada documento almacenado en una colección requiere un campo _id único que actúa como clave principal. Si un documento insertado omite el _id campo, el controlador de MongoDB genera automáticamente un ObjectId para el _id campo.
Esto también se aplica a los documentos insertados mediante operaciones de actualización con inserción: true.
Atomicidad
Todas las operaciones de escritura en MongoDB son atómicas a nivel de un solo documento. Para más información sobre MongoDB y la atomicidad, consulte Atomicidad y Transacciones.
Guardar reconocimiento
Con las preocupaciones de escritura, puede especificar el nivel de confirmación solicitado a MongoDB para las operaciones de escritura. Para más información,consulte "Preocupación de escritura".