db.colección.insertMany() (método mongosh)

Parámetros

Ejecución de operaciones

Por defecto, los documentos se insertan en el orden en que se proporcionan.

• Si ordered se establece en true y falla una inserción, el servidor no continúa insertando registros.

• Si ordered se establece en false y se produce un error en la inserción, el servidor continúa insertando registros. Los documentos pueden reordenarse mediante mongod para aumentar el rendimiento. Las aplicaciones no deberían depender del orden de las inserciones si se utiliza un insertMany() no ordenado.

La ejecución de una ordered lista de operaciones en una colección particionada generalmente será más lenta que la ejecución de una lista unordered, ya que con una lista ordenada, cada operación debe esperar a que la anterior termine.

Límites y agrupamiento

El controlador agrupa los documentos especificados en la insertMany() matriz y no hay límite para la cantidad de documentos que la base de datos puede gestionar. El controlador agrupa los datos en lotes según el valor maxWriteBatchSize, que 100 es,000 y no se puede modificar. Por ejemplo, si la insertMany() operación 250 contiene,000 documentos, el controlador crea tres lotes: dos con,100 000 documentos y uno 50 con,000 documentos.

Si el informe de errores de un solo grupo crece demasiado, MongoDB trunca todos los mensajes de error restantes. Si hay al menos dos mensajes de error con un tamaño mayor que 1MB, esos mensajes se truncan.

Los tamaños y la mecánica de agrupación son detalles internos de rendimiento y están sujetos a cambios en versiones futuras.

Colección y _id creación de campos

Si la colección no existe, entonces insertMany() crea la colección.

Si el documento a insertar no especifica un campo _id, entonces mongod agrega el campo _id y asigna un ObjectId() único para el documento. La mayoría de los controladores crean un ObjectId e insertan el campo _id, pero el mongod lo creará y completará el _id si el controlador o la aplicación no lo hacen.

Si el documento contiene un campo _id, el valor de _id debe ser único dentro de la colección para evitar un error de clave duplicada.

Explicabilidad

insertMany() no es compatible db.collection.explain() con.

Error Handling

Las inserciones generan una excepción BulkWriteError.

Excluyendo los errores de nivel de confirmación de escritura, las operaciones ordenadas se detienen después de un error, mientras que las operaciones no ordenadas continúan procesando las operaciones de escritura restantes en la cola.

Los errores de niveles de confirmación de escritura se muestran en el campo writeConcernErrors, mientras que todos los demás errores se muestran en el campo writeErrors. Si se encuentra un error, se muestra el número de operaciones de guardado exitosas en lugar de una lista de _ids insertados. Las operaciones ordenadas muestran el único error encontrado, mientras que las operaciones desordenadas muestran cada error en un arreglo.

Transacciones

insertMany() se puede utilizar dentro de transacciones distribuidas.

Consideraciones sobre el rendimiento para datos aleatorios

Si una Operación inserta una gran cantidad de datos aleatorios (por ejemplo, índices encriptados) en un campo indexado, el rendimiento de las inserciones puede disminuir. Las inserciones masivas de datos aleatorios generan entradas de índice aleatorias, lo que incrementa el tamaño del índice. Si el índice alcanza un tamaño que requiere que cada inserción aleatoria acceda a una entrada de índice diferente, las inserciones resultan en una alta tasa de desalojo y reemplazo de la caché de WiredTiger. Cuando esto ocurre, el índice deja de estar completamente en caché y se actualiza en el disco, lo que reduce el rendimiento.

Para mejorar el rendimiento de las inserciones masivas de datos aleatorios en campos de índice, puedes:

• Descartar el índice y luego volver a crearlo después de insertar los datos aleatorios.

• Inserta los datos en una colección vacía sin índice.

Crear el índice después de la inserción masiva ordena los datos en memoria y realiza una inserción ordenada en todos los índices.

Entradas de OpLog

MongoDB consolida las operaciones que insertan varios documentos, como insertMany() o varios insertOne() comandos dentro de una operación, en una db.collection.bulkWrite() sola entrada del registro de operaciones. Si la operación falla, no se añade ninguna entrada al registro de operaciones.

Insertar varios documentos sin especificar un _id campo

El siguiente ejemplo utiliza insertMany() para insertar documentos que no contienen el campo _id:

try {
   db.products.insertMany( [
      { item: "card", qty: 15 },
      { item: "envelope", qty: 20 },
      { item: "stamps" , qty: 30 }
   ] );
} catch (e) {
   print (e);
}

La operación devuelve el siguiente documento:

{
   "acknowledged" : true,
   "insertedIds" : [
      ObjectId("562a94d381cb9f1cd6eb0e1a"),
      ObjectId("562a94d381cb9f1cd6eb0e1b"),
      ObjectId("562a94d381cb9f1cd6eb0e1c")
   ]
}

Debido a que los documentos no incluían,_id mongod _id <a class=\" \" href=\" \"> crea y añade el campo y le asigna un valor único de <a class=\" \" href=\" \">.ObjectId()

Los valores de ObjectId son específicos de la máquina y del momento en que se ejecuta la operación. Por lo tanto, tus valores pueden diferir de los del ejemplo.

Inserta varios documentos que especifiquen un campo _id.

El siguiente ejemplo usa insertMany() para insertar documentos que incluyen el campo _id. El valor de _id debe ser único dentro de la colección para evitar un error de clave duplicada.

try {
   db.products.insertMany( [
      { _id: 10, item: "large box", qty: 20 },
      { _id: 11, item: "small box", qty: 55 },
      { _id: 12, item: "medium box", qty: 30 }
   ] );
} catch (e) {
   print (e);
}

La operación devuelve el siguiente documento:

{ "acknowledged" : true, "insertedIds" : [ 10, 11, 12 ] }

Insertar un valor duplicado para cualquier clave que forme parte de un índice único, como _id, provoca una excepción. Lo siguiente intenta insertar un documento con un valor _id que ya existe:

try {
   db.products.insertMany( [
      { _id: 13, item: "envelopes", qty: 60 },
      { _id: 13, item: "stamps", qty: 110 },
      { _id: 14, item: "packing tape", qty: 38 }
   ] );
} catch (e) {
   print (e);
}

Dado que _id: 13 ya existe, se lanza la siguiente excepción:

BulkWriteError({
   "writeErrors" : [
      {
         "index" : 0,
         "code" : 11000,
         "errmsg" : "E11000 duplicate key error collection: inventory.products index: _id_ dup key: { : 13.0 }",
         "op" : {
            "_id" : 13,
            "item" : "stamps",
            "qty" : 110
         }
      }
   ],
   "writeConcernErrors" : [ ],
   "nInserted" : 1,
   "nUpserted" : 0,
   "nMatched" : 0,
   "nModified" : 0,
   "nRemoved" : 0,
   "upserted" : [ ]
})

Ten en cuenta que se insertó un documento: el primer documento de _id: 13 se insertará correctamente, pero la segunda inserción fallará. Esto también impedirá que se inserten documentos adicionales que queden en la cola.

Con ordered a false, la operación de inserción continuaría con los documentos restantes.

Inserciones desordenadas

Los siguientes intentos de insertar múltiples documentos con el campo _id y ordered: false. El arreglo de documentos contiene dos documentos con campos _id duplicados.

try {
   db.products.insertMany( [
      { _id: 10, item: "large box", qty: 20 },
      { _id: 11, item: "small box", qty: 55 },
      { _id: 11, item: "medium box", qty: 30 },
      { _id: 12, item: "envelope", qty: 100},
      { _id: 13, item: "stamps", qty: 125 },
      { _id: 13, item: "tape", qty: 20},
      { _id: 14, item: "bubble wrap", qty: 30}
   ], { ordered: false } );
} catch (e) {
   print (e);
}

La operación lanza la siguiente excepción:

BulkWriteError({
   "writeErrors" : [
      {
         "index" : 2,
         "code" : 11000,
         "errmsg" : "E11000 duplicate key error collection: inventory.products index: _id_ dup key: { : 11.0 }",
         "op" : {
            "_id" : 11,
            "item" : "medium box",
            "qty" : 30
         }
      },
      {
         "index" : 5,
         "code" : 11000,
         "errmsg" : "E11000 duplicate key error collection: inventory.products index: _id_ dup key: { : 13.0 }",
         "op" : {
            "_id" : 13,
            "item" : "tape",
            "qty" : 20
         }
      }
   ],
   "writeConcernErrors" : [ ],
   "nInserted" : 5,
   "nUpserted" : 0,
   "nMatched" : 0,
   "nModified" : 0,
   "nRemoved" : 0,
   "upserted" : [ ]
})

Aunque el documento con item: "medium box" y item: "tape" no se pudo insertar debido a valores _id duplicados, nInserted muestra que se insertaron los 5 documentos restantes.

Usando Nivel de Confirmación de Escritura

Dado un set de réplicas de tres nodos, la siguiente operación especifica un w de majority y un wtimeout de 100:

try {
   db.products.insertMany(
      [
         { _id: 10, item: "large box", qty: 20 },
         { _id: 11, item: "small box", qty: 55 },
         { _id: 12, item: "medium box", qty: 30 }
      ],
      { w: "majority", wtimeout: 100 }
   );
} catch (e) {
   print (e);
}

Si el primario y al menos un secundario reconocen cada operación de guardado en un plazo de 100 milisegundos, devuelve:

{
  "acknowledged" : true,
  "insertedIds" : [
     ObjectId("562a94d381cb9f1cd6eb0e1a"),
     ObjectId("562a94d381cb9f1cd6eb0e1b"),
     ObjectId("562a94d381cb9f1cd6eb0e1c")
  ]
}

Si el tiempo total requerido para que todos los Nodos necesarios en el set de réplicas reconozcan la operación de escritura es mayor que wtimeout, se muestra el siguiente writeConcernError cuando ha pasado el período de wtimeout.

Esta operación devuelve:

WriteConcernError({
   "code" : 64,
   "errmsg" : "waiting for replication timed out",
   "errInfo" : {
     "wtimeout" : true,
     "writeConcern" : {
       "w" : "majority",
       "wtimeout" : 100,
       "provenance" : "getLastErrorDefaults"
     }
   }
})