/ /

Operaciones masivas

Overview

En esta guía, puedes aprender a usar el driver de Node.js para realizar operaciones en masa. Las operaciones masivas ayudan a reducir el número de llamadas al servidor. En lugar de enviar una solicitud para cada operación, puedes realizar múltiples operaciones dentro de una sola acción.

Tip

Para obtener más información sobre operaciones masivas, consulta Operaciones de escritura masiva en el manual de MongoDB Server.

Puedes usar operaciones masivas para realizar múltiples operaciones de guardado en una colección. También puedes ejecutar operaciones masivas desde el cliente, lo que te permite realizar escrituras masivas en varios namespaces. En MongoDB, un namespace consta del nombre de la base de datos y el nombre de la colección en el formato <database>.<collection>.

Nota

No hay límite en la cantidad de operaciones de escritura que un driver puede gestionar. Los drivers agrupan los datos en lotes según el maxWriteBatchSize, que es de 100,000 y no puede ser modificado. Si el lote contiene más de 100,000 operaciones, el controlador divide el lote en grupos más pequeños con conteos menores o iguales a la maxWriteBatchSize. Por ejemplo, si la operación contiene 250,000 operaciones, el controlador crea tres lotes: dos con 100,000 operaciones y uno con 50,000 operaciones.

Esta guía incluye las siguientes secciones:

Operaciones de inserción masiva describe cómo realizar operaciones de inserción masiva en tu colección o cliente.
Operaciones de reemplazo masivo describe cómo realizar operaciones de reemplazo masivo en tu colección o cliente.
Operaciones de actualización masiva describe cómo realizar operaciones de actualización masiva en tu colección o cliente.
Operaciones de eliminación masiva describe cómo realizar operaciones de eliminación masiva en tu colección o cliente.
Tipo de retorno describe el objeto de retorno que resulta de tus operaciones masivas de guardado.
Gestión de excepciones describe las excepciones que se producen si alguna de las operaciones en una operación de escritura masiva falla.
Información Adicional proporciona enlaces a recursos y documentación de API para los tipos y métodos mencionados en esta guía.

Importante

Requisitos de versión del servidor y del controlador

Las operaciones de guardar masiva a nivel de colección requieren las siguientes versiones:

Versión 7600 de MongoDB Server o posterior 3.2
Versión del driver Node.js 3.6 o posterior

Las operaciones de escritura masiva a nivel de cliente requieren las siguientes versiones:

Versión 7600 de MongoDB Server o posterior 8.0
Versión del driver Node.js 6.10 o posterior

Datos de muestra

Los ejemplos de esta guía utilizan las colecciones movies y users en la base de datos sample_mflix, que se incluye en los conjuntos de datos de muestra de Atlas. Para aprender a crear un clúster gratuito de MongoDB Atlas y cargar los conjuntos de datos de muestra, consulta la guía MongoDB Get Started.

Operaciones de inserción masiva

Para realizar una inserción masiva, cree un modelo de operación masiva para cada documento que desee insertar. Luego, pasa una lista de estos modelos al método bulkWrite().

Esta sección describe cómo realizar los siguientes tipos de operaciones masivas:

Inserciones masivas en la colección

Para realizar una operación de inserción masiva en tu colección, crea un InsertOneModel para cada operación. Después, llama al método bulkWrite() en tu colección y pasa un arreglo de modelos como parámetro. Para crear un InsertOneModel, especifica el campo document del modelo y configúralo en el documento que deseas insertar.

Ejemplo

Este ejemplo realiza las siguientes acciones:

Especifica dos instancias de InsertOneModel en un arreglo. Cada InsertOneModel representa un documento para insertar en la colección movies en la base de datos sample_mflix.
Llama al método bulkWrite() en la colección movies y pasa un arreglo de modelos como parámetro.
Imprime el número de documentos insertados.

const insertModels = [{
    insertOne: {
        document: {
            title: "The Favourite",
            year: 2018,
            rated: "R",
            released: "2018-12-21"
        }
    }
}, {
    insertOne: {
        document: {
            title: "I, Tonya",
            year: 2017,
            rated: "R",
            released: "2017-12-08"
        }
    }
}];
const insertResult = await movies.bulkWrite(insertModels);
console.log(`Inserted documents: ${insertResult.insertedCount}`);

Inserted documents: 2

Inserciones en lote de clientes

Para realizar una operación de inserción masiva en varias colecciones o bases de datos, cree un ClientBulkWriteModel para cada operación. Luego, llama al método bulkWrite() en tu cliente y pasa un arreglo de modelos como parámetro.

La siguiente tabla describe los campos que puede establecer en un ClientBulkWriteModel para especificar una operación de inserción:

Campo	Descripción
`namespace`	El espacio de nombres en el que se insertará un documento. Tipo: `String`
`name`	La operación que desea realizar. Para operaciones de inserción, establezca este campo `"insertOne"` en. Tipo: `String`
`document`	El documento a insertar. Tipo: `Document`

Ejemplo

Este ejemplo realiza las siguientes acciones:

Especifica tres instancias de ClientBulkWriteModel en un arreglo. Los dos primeros modelos representan documentos para insertar en la colección movies, y el último modelo representa un documento para insertar en la colección users.
Llama al método bulkWrite() en un cliente y pasa un arreglo de modelos como parámetro.
Imprime el número de documentos insertados.

const clientInserts = [{
    namespace: "sample_mflix.movies",
    name: "insertOne",
    document: {
        title: "The Favourite",
        year: 2018,
        rated: "R",
        released: "2018-12-21"
    }
}, {
    namespace: "sample_mflix.movies",
    name: "insertOne",
    document: {
        title: "I, Tonya",
        year: 2017,
        rated: "R",
        released: "2017-12-08"
    }
}, {
    namespace: "sample_mflix.users",
    name: "insertOne",
    document: {
        name: "Brian Schwartz",
        email: "bschwartz@example.com"
    }
}];
const clientInsertRes = await client.bulkWrite(clientInserts);
console.log(`Inserted documents: ${clientInsertRes.insertedCount}`);

Inserted documents: 3

Operaciones de reemplazo masivo

Para realizar una operación de reemplazo masivo, cree un modelo de operación masiva para cada documento que desee reemplazar. Luego, pasa una lista de estos modelos al método bulkWrite().

Esta sección describe cómo realizar los siguientes tipos de operaciones masivas:

Reemplazos masivos de colección

Para realizar una operación de reemplazo masivo en tu colección, crea un ReplaceOneModel para cada operación. Luego, llame al método bulkWrite() en su colección y pase un arreglo de modelos como parámetro.

La siguiente tabla describe los campos que se pueden establecer en un ReplaceOneModel:

Campo	Descripción
`filter`	El filtro que coincide con el documento que desea reemplazar. Tipo: `Document`
`replacement`	El documento de reemplazo. Tipo: `Document`
`collation`	(Opcional) La intercalación que se utilizará para ordenar los resultados. Para obtener más información sobre las intercalaciones, consulte la sección Intercalación de la guía Configurar operaciones CRUD. Tipo: `String` o `Object`
`hint`	(Opcional) El índice que se utilizará para la operación. Para obtener más información sobre los índices, consulte la guía Índices para la optimización de consultas. Tipo: `Bson`
`upsert`	(Opcional) Indica si se crea un nuevo documento si no se encuentra ninguno que coincida con el filtro. Por defecto, este campo está configurado `false` en. Tipo: `Boolean`

Ejemplo

Este ejemplo realiza las siguientes acciones:

Especifica dos instancias de ReplaceOneModel en un arreglo. Las instancias ReplaceOneModel contienen instrucciones para reemplazar documentos que representan películas en la colección movies.
Llama al método bulkWrite() en la colección movies y pasa un arreglo de modelos como parámetro.
Imprime la cantidad de documentos modificados.

const replaceOperations = [{
    replaceOne: {
        filter: {
            title: "The Dark Knight"
        },
        replacement: {
            title: "The Dark Knight Rises",
            year: 2012,
            rating: "PG-13"
        },
        upsert: false
    }
}, {
    replaceOne: {
        filter: {
            title: "Inception"
        },
        replacement: {
            title: "Inception Reloaded",
            year: 2010,
            rating: "PG-13"
        },
        upsert: false
    }
}];
const replaceResult = await movies.bulkWrite(replaceOperations);
console.log(`Modified documents: ${replaceResult.modifiedCount}`);

Modified documents: 2

Reemplazos masivos de clientes

Para realizar una operación masiva de sustitución en varias colecciones o bases de datos, cree un ClientBulkWriteModel para cada operación. Luego, llama al método bulkWrite() en tu cliente y pasa un arreglo de modelos como parámetro.

La siguiente tabla describe los campos que puedes configurar en un ClientBulkWriteModel para especificar una operación de reemplazo:

Campo	Descripción
`namespace`	El espacio de nombres en el que se reemplazará un documento. Tipo: `String`
`name`	La operación que desea realizar. Para operaciones de reemplazo, establezca este campo `"replaceOne"` en. Tipo: `String`
`filter`	El filtro que coincide con el documento que desea reemplazar. Tipo: `Document`
`replacement`	El documento de reemplazo. Tipo: `Document`
`collation`	(Opcional) La intercalación que se utilizará para ordenar los resultados. Para obtener más información sobre las intercalaciones, consulte la sección Intercalación de la guía Configurar operaciones CRUD. Tipo: `String` o `Object`
`hint`	(Opcional) El índice que se utilizará para la operación. Para obtener más información sobre los índices, consulte la guía Índices para la optimización de consultas. Tipo: `Bson`

Ejemplo

Este ejemplo realiza las siguientes acciones:

Especifica tres instancias ClientBulkWriteModel en un arreglo. Los dos primeros modelos contienen instrucciones de reemplazo para documentos en la colección movies, y el último modelo contiene instrucciones de reemplazo para un documento en la colección users.
Llama al método bulkWrite() en un cliente y pasa un arreglo de modelos como parámetro.
Imprime la cantidad de documentos modificados.

const clientReplacements = [{
    namespace: "sample_mflix.movies",
    name: "replaceOne",
    filter: {
        title: "The Dark Knight"
    },
    replacement: {
        title: "The Dark Knight Rises",
        year: 2012,
        rating: "PG-13"
    }
}, {
    namespace: "sample_mflix.movies",
    name: "replaceOne",
    filter: {
        title: "Inception"
    },
    replacement: {
        title: "Inception Reloaded",
        year: 2010,
        rating: "PG-13"
    }
}, {
    namespace: "sample_mflix.users",
    name: "replaceOne",
    filter: {
        name: "April Cole"
    },
    replacement: {
        name: "April Franklin",
        email: "aprilfrank@example.com"
    }
}];
const clientReplaceRes = await client.bulkWrite(clientReplacements);
console.log(`Modified documents: ${clientReplaceRes.modifiedCount}`);

Modified documents: 3

Operaciones de actualización masiva

Para realizar una operación de actualización masiva, crea un modelo de operación masiva para cada actualización que desees realizar. Luego, pasa una lista de estos modelos al método bulkWrite().

Esta sección describe cómo realizar los siguientes tipos de operaciones masivas:

Actualizaciones masivas de colecciones

Para realizar una operación de actualización masiva en tu colección, crea un UpdateOneModel o UpdateManyModel para cada operación. Luego, llama al método bulkWrite() en tu colección y pasa un arreglo de modelos como parámetro. Una UpdateOneModel solo actualiza un documento que coincide con un filtro, mientras que una UpdateManyModel actualiza todos los documentos que coinciden con un filtro.

La siguiente tabla describe los campos que puedes establecer en un UpdateOneModel o UpdateManyModel:

Campo	Descripción
`filter`	El filtro que coincide con uno o más documentos que desea actualizar. Si se especifica `UpdateOneModel` en, solo se actualizará el primer documento que coincida. Si se especifica `UpdateManyModel` en, se actualizarán todos los documentos que coincidan. Tipo: `Document`
`update`	La actualización a realizar. Tipo: `Document`
`arrayFilters`	(Opcional) Un conjunto de filtros que especifican a qué elementos de la matriz se aplica una actualización si se está actualizando un campo con valor de matriz. Tipo: `Array`
`collation`	(Opcional) La intercalación que se utilizará al ordenar los resultados. Para obtener más información sobre las intercalaciones, consulte la sección Intercalación de la guía Configurar operaciones CRUD. Tipo: `Object`
`hint`	(Opcional) El índice que se utilizará para la operación. Para obtener más información sobre los índices, consulte la guía Índices para la optimización de consultas. Tipo: `String or Object`
`upsert`	(Opcional) Indica si se crea un nuevo documento si no se encuentra ninguno que coincida con el filtro. Por defecto, este campo está configurado `false` en. Tipo: `Boolean`

Ejemplo

Este ejemplo realiza las siguientes acciones:

Especifica una instancia UpdateOneModel y una UpdateManyModel en un arreglo. Estos modelos contienen instrucciones para actualizar documentos que representan películas en la colección movies.
Llama al método bulkWrite() en la colección movies y pasa un arreglo de modelos como parámetro.
Imprime la cantidad de documentos modificados.

const updateOperations = [{
    updateOne: {
        filter: {
            title: "Interstellar"
        },
        update: {
            $set: {
                title: "Interstellar Updated",
                genre: "Sci-Fi Adventure"
            }
        },
        upsert: true
    }
}, {
    updateMany: {
        filter: {
            rated: "PG-13"
        },
        update: {
            $set: {
                rated: "PG-13 Updated",
                genre: "Updated Genre"
            }
        }
    }
}];
const updateResult = await movies.bulkWrite(updateOperations);
console.log(`Modified documents: ${updateResult.modifiedCount}`);

Modified documents: 2320

Actualizaciones masivas de clientes

Para realizar una operación de actualización masiva en varias colecciones o bases de datos, crea un ClientBulkWriteModel para cada operación. Luego, llama al método bulkWrite() en tu cliente y pasa un arreglo de modelos como parámetro.

La siguiente tabla describe los campos que puede establecer en un ClientBulkWriteModel para especificar una operación de actualización:

Campo	Descripción
`namespace`	El espacio de nombres en el que se actualizará un documento. Tipo: `String`
`name`	La operación que desea realizar. Para operaciones de actualización, establezca este campo en `"updateOne"` `"updateMany"`o. Tipo: `String`
`filter`	El filtro que coincide con uno o más documentos que desea actualizar. Si establece el modelo `name` `"updateOne"`en, solo se actualizará el primer documento que coincida. Si `name` establece `"updateMany"` en, se actualizarán todos los documentos que coincidan. Tipo: `Document`
`update`	Las actualizaciones a realizar. Tipo: `Document` o `Document[]`
`arrayFilters`	(Opcional) Un conjunto de filtros que especifican a qué elementos de la matriz se aplica una actualización si se está actualizando un campo con valor de matriz. Tipo: `Document[]`
`collation`	(Opcional) La intercalación que se utilizará al ordenar los resultados. Para obtener más información sobre las intercalaciones, consulte la sección Intercalación de la guía Configurar operaciones CRUD. Tipo: `Document`
`hint`	(Opcional) El índice que se utilizará para la operación. Para obtener más información sobre los índices, consulte la guía Índices para la optimización de consultas. Tipo: `Document` o `String`
`upsert`	(Opcional) Indica si se crea un nuevo documento si no se encuentra ninguno que coincida con el filtro. Por defecto, este campo está configurado `false` en. Tipo: `Boolean`

Ejemplo

Este ejemplo realiza las siguientes acciones:

Especifica dos instancias de ClientBulkWriteModel en un arreglo. El primer modelo especifica una operación de actualización de muchos en la colección movies, y el segundo modelo especifica una operación de actualización de uno en la colección users.
Llama al método bulkWrite() en un cliente y pasa un arreglo de modelos como parámetro.
Imprime la cantidad de documentos modificados.

const clientUpdates = [{
    namespace: "sample_mflix.movies",
    name: "updateMany",
    filter: {
        rated: "PG-13"
    },
    update: {
        $set: {
            rated: "PG-13 Updated",
            genre: "Updated Genre"
        }
    },
    upsert: false
}, {
    namespace: "sample_mflix.users",
    name: "updateOne",
    filter: {
        name: "Jon Snow"
    },
    update: {
        $set: {
            name: "Aegon Targaryen",
            email: "targaryen@example.com"
        }
    },
    upsert: false
}];
const clientUpdateRes = await client.bulkWrite(clientUpdates);
console.log(`Modified documents: ${clientUpdateRes.modifiedCount}`);

Modified documents: 2320

Operaciones de eliminación masiva

Para realizar una operación de eliminación masiva, crea un modelo de operación masiva para cada operación de eliminación. Luego, pasa una lista de estos modelos al método bulkWrite().

Esta sección describe cómo realizar los siguientes tipos de operaciones masivas:

Eliminaciones masivas de la colección

Para realizar una operación de borrar masiva en tu colección, crea un DeleteOneModel o un DeleteManyModel para cada operación. A continuación, llama al método bulkWrite() en tu colección y pasa un arreglo de modelos como parámetro. Un DeleteOneModel elimina solo un documento que coincida con un filtro, mientras que un DeleteManyModel elimina todos los documentos que coinciden con un filtro.

La siguiente tabla describe los campos que se pueden configurar en un DeleteOneModel o DeleteManyModel:

Campo	Descripción
`filter`	El filtro que coincide con uno o más documentos que desea eliminar. Si se especifica `DeleteOneModel` en, solo se eliminará el primer documento que coincida. Si se especifica `DeleteManyModel` en, se eliminarán todos los documentos que coincidan. Tipo: `Document`
`collation`	(Opcional) La intercalación que se utilizará al ordenar los resultados. Para obtener más información sobre las intercalaciones, consulte la sección Intercalación de la guía Configurar operaciones CRUD. Tipo: `Object`
`hint`	(Opcional) El índice que se utilizará para la operación. Para obtener más información sobre los índices, consulte la guía Índices para la optimización de consultas. Tipo: `String or Object`

Ejemplo

Este ejemplo realiza las siguientes acciones:

Especifica una instancia de DeleteOneModel y una de DeleteManyModel en un arreglo. Estos modelos contienen instrucciones para borrar documentos en la colección movies.
Llama al método bulkWrite() en la colección movies y pasa un arreglo de modelos como parámetro.
Imprime el número de documentos eliminados.

const deleteOperations = [{
    deleteOne: {
        filter: {
            title: "Dunkirk"
        }
    }
}, {
    deleteMany: {
        filter: {
            rated: "R"
        }
    }
}];
const deleteResult = await movies.bulkWrite(deleteOperations);
console.log(`Deleted documents: ${deleteResult.deletedCount}`);

Deleted documents: 5538

Eliminaciones masivas de clientes

Para realizar una operación de eliminación masiva en varias colecciones o bases de datos, crea un ClientBulkWriteModel para cada operación. Luego, debes llamar al método bulkWrite() en tu cliente y pasar un arreglo de modelos como parámetro.

La siguiente tabla describe los campos que puede configurar en un ClientBulkWriteModel para especificar una operación de borrado:

Campo	Descripción
`namespace`	El espacio de nombres en el que se eliminará un documento. Tipo: `String`
`name`	La operación que desea realizar. Para operaciones de eliminación, establezca este campo `"deleteOne"` en `"deleteMany"` o. Tipo: `String`
`filter`	El filtro que coincide con uno o más documentos que desea eliminar. Si establece el modelo `name` `"deleteOne"`en, solo se eliminará el primer documento que coincida. Si `name` establece `"deleteMany"` en, se eliminarán todos los documentos que coincidan. Tipo: `Document`
`hint`	(Opcional) El índice que se utilizará para la operación. Para obtener más información sobre los índices, consulte la guía Índices para la optimización de consultas. Tipo: `Document` o `String`
`collation`	(Opcional) La intercalación que se utilizará al ordenar los resultados. Para obtener más información sobre las intercalaciones, consulte la sección Intercalación de la guía Configurar operaciones CRUD. Tipo: `Document`

Ejemplo

Este ejemplo realiza las siguientes acciones:

Especifica dos instancias de ClientBulkWriteModel en un arreglo. El primer modelo especifica una operación de borrar muchos en la colección movies, y el segundo modelo especifica una operación de borrar uno en la colección users.
Llama al método bulkWrite() en un cliente y pasa un arreglo de modelos como parámetro.
Imprime la cantidad de documentos modificados.

const clientDeletes = [{
    namespace: "sample_mflix.movies",
    name: "deleteMany",
    filter: {
        rated: "R"
    }
}, {
    namespace: "sample_mflix.users",
    name: "deleteOne",
    filter: {
        email: "emilia_clarke@gameofthron.es"
    }
}];
const clientDeleteRes = await client.bulkWrite(clientDeletes);
console.log(`Deleted documents: ${clientDeleteRes.deletedCount}`);

Deleted documents: 5538

Tipo de devolución

BulkWriteResult

El método Collection.bulkWrite() devuelve un objeto BulkWriteResult, que proporciona información sobre tu operación en masa.

Las siguientes tablas describen los campos de un objeto BulkWriteResult:

Campo	Descripción
`insertedCount`	El número de documentos insertados
`matchedCount`	El número de documentos coincidentes
`modifiedCount`	El número de documentos actualizados
`upsertedCount`	El número de documentos insertados
`deletedCount`	La cantidad de documentos borrados

ClientBulkWriteResult

El método MongoClient.bulkWrite() devuelve un objeto ClientBulkWriteResult, que incluye información sobre la operación de escritura masiva del cliente.

Las siguientes tablas describen los campos de un objeto ClientBulkWriteResult:

Campo	Descripción
`acknowledged`	Un valor booleano que indica si la escritura masiva fue reconocida
`insertedCount`	El número de documentos insertados
`matchedCount`	El número de documentos coincidentes
`modifiedCount`	El número de documentos actualizados
`upsertedCount`	El número de documentos insertados
`deletedCount`	La cantidad de documentos borrados
`insertResults`	Los resultados de cada operación individual de inserción exitosa
`updateResults`	Los resultados de cada operación de actualización individual exitosa
`deleteResults`	Los resultados de cada operación de borrado individual exitosa

Manejo de excepciones

Excepciones de escritura masiva en la colección

Si alguna operación masiva de guardado que se invoque en una colección no tiene éxito, el driver de Node.js arroja un MongoBulkWriteError y no realiza ninguna operación adicional si la opción ordered está establecida en true. Si ordered está configurado en false, intentará continuar con las operaciones posteriores.

Tip

Para obtener más información sobre las operaciones masivas ordenadas y desordenadas, vea la sección Operaciones ordenadas vs operaciones desordenadas en la guía Bulk Write del manual de MongoDB Server.

Un objeto MongoBulkWriteError contiene las siguientes propiedades:

Propiedad	Descripción
`message`	El mensaje de error. Tipo: `String`
`writeErrors`	Una serie de errores que se produjeron durante la operación de escritura masiva. Tipo: `BulkWriteError[]`
`writeConcernErrors`	Errores de escritura que ocurrieron durante la ejecución de la operación de escritura masiva. Tipo: `WriteConnectionError[]`
`result`	Resultados de cualquier operación exitosa realizada antes de que se produjera la excepción. Tipo: `BulkWriteResult[]`
`err`	El objeto de error subyacente, que puede contener más detalles. Tipo: `Error`

Excepciones de escritura masiva del cliente

Si alguna operación de escritura masiva llamada en el cliente no fue exitosa, el driver Node.js genera un MongoClientBulkWriteError. Por defecto, el controlador no realiza ninguna operación subsiguiente tras encontrar un error. Si se pasa la opción ordered al método bulkWrite() y se configura en false, el driver continuará intentando las operaciones restantes.

Un objeto MongoClientBulkWriteError contiene las siguientes propiedades:

Propiedad	Descripción
`writeConcernErrors`	Una matriz de documentos que especifica cada error de escritura. Tipo: `Document[]`
`writeErrors`	Mapa de errores ocurridos durante operaciones de escritura individuales. Tipo: `Map<number, ClientBulkWriteError>`
`partialResult`	Resultado parcial de la escritura masiva del cliente que refleja el progreso de la operación antes del error. Tipo: `ClientBulkWriteResult`

bulkWrite() Ejemplo: Archivo Completo

Nota

Configuración de ejemplo

Este ejemplo se conecta a una instancia de MongoDB con un URI de conexión. Para obtener más información sobre cómo realizar la conexión a la instancia de MongoDB, se debe consultar la guía Conexión a MongoDB. Este ejemplo también usa la colección movies en la base de datos sample_mflix incluida en los conjuntos de datos de muestra de Atlas. Se pueden cargar en la base de datos en el nivel gratuito de MongoDB Atlas siguiendo la guía de Introducción a MongoDB.

El siguiente código es un archivo completo y autónomo que realiza una operación de escritura masiva en la colección theaters de la base de datos sample_mflix. El parámetro operations incluye ejemplos de operaciones de guardado insertOne, updateMany y deleteOne:

1 // Bulk write operation
2 
3 // Import MongoClient from the MongoDB node driver package
4 const { MongoClient } = require("mongodb");
5 
6 // Replace the uri string with your MongoDB deployment's connection string
7 const uri = "<connection string uri>";
8 
9 const client = new MongoClient(uri);
10 
11 async function run() {
12   try {
13     const database = client.db("sample_mflix");
14     const theaters = database.collection("theaters");
15 
16     // Insert a new document into the "theaters" collection
17     const result = await theaters.bulkWrite([
18       {
19         insertOne: {
20           document: {
21             location: {
22               address: {
23                 street1: "3 Main St.",
24                 city: "Anchorage",
25                 state: "AK",
26                 zipcode: "99501",
27               },
28             },
29           },
30         },
31       },
32       {
33         insertOne: {
34           document: {
35             location: {
36               address: {
37                 street1: "75 Penn Plaza",
38                 city: "New York",
39                 state: "NY",
40                 zipcode: "10001",
41               },
42             },
43           },
44         },
45       },
46       {
47         // Update documents that match the specified filter
48         updateMany: {
49           filter: { "location.address.zipcode": "44011" },
50           update: { $set: { is_in_ohio: true } },
51           upsert: true,
52         },
53       },
54       {
55         // Delete a document that matches the specified filter
56         deleteOne: { filter: { "location.address.street1": "221b Baker St" } },
57       },
58     ]);
59     // Log the result of the bulk write operation 
60     console.log(result);
61   } finally {
62     // Close the database connection when the operations are completed or if an error occurs
63     await client.close();
64   }
65 }
66 run().catch(console.dir);

1 import { MongoClient } from "mongodb";
2 
3 // Replace the uri string with your MongoDB deployment's connection string.
4 const uri = "<connection string uri>";
5 
6 const client = new MongoClient(uri);
7 
8 interface Address {
9   street1: string;
10   city: string;
11   state: string;
12   zipcode: string;
13 }
14 
15 interface Theater {
16   location: { address: Address };
17   is_in_ohio?: boolean;
18 }
19 
20 async function run() {
21   try {
22     const database = client.db("sample_mflix");
23     const theaters = database.collection<Theater>("theaters");
24 
25     const result = await theaters.bulkWrite([
26       {
27         insertOne: {
28           document: {
29             location: {
30               address: {
31                 street1: "3 Main St.",
32                 city: "Anchorage",
33                 state: "AK",
34                 zipcode: "99501",
35               },
36             },
37           },
38         },
39       },
40       {
41         insertOne: {
42           document: {
43             location: {
44               address: {
45                 street1: "75 Penn Plaza",
46                 city: "New York",
47                 state: "NY",
48                 zipcode: "10001",
49               },
50             },
51           },
52         },
53       },
54       {
55         updateMany: {
56           // Important: You lose type safety when you use dot notation in queries
57           filter: { "location.address.zipcode": "44011" },
58           update: { $set: { is_in_ohio: true } },
59           upsert: true,
60         },
61       },
62       {
63         deleteOne: {
64           filter: { "location.address.street1": "221b Baker St" },
65         },
66       },
67     ]);
68 
69     console.log(result);
70   } finally {
71     await client.close();
72   }
73 }
74 run().catch(console.dir);

Al ejecutar el ejemplo anterior, se produce el siguiente resultado:

BulkWriteResult {
  insertedCount: 2,
  matchedCount: 1,
  modifiedCount: 1,
  deletedCount: 0,
  upsertedCount: 0,
  upsertedIds: {},
  insertedIds: {
    '0': new ObjectId("..."),
    '1': new ObjectId("...")
  }
}

Información Adicional

Para obtener más información sobre operaciones masivas, consulta Operaciones de escritura masiva en el manual de MongoDB Server.

Documentación de la API

Para aprender más sobre cualquiera de los métodos o tipos analizados en esta guía, consulta la siguiente documentación de API:

Volver

Delete Documents

Operaciones compuestas

1	// Bulk write operation
2
3	// Import MongoClient from the MongoDB node driver package
4	const { MongoClient } = require("mongodb");
5
6	// Replace the uri string with your MongoDB deployment's connection string
7	const uri = "<connection string uri>";
8
9	const client = new MongoClient(uri);
10
11	async function run() {
12	try {
13	const database = client.db("sample_mflix");
14	const theaters = database.collection("theaters");
15
16	// Insert a new document into the "theaters" collection
17	const result = await theaters.bulkWrite([
18	{
19	insertOne: {
20	document: {
21	location: {
22	address: {
23	street1: "3 Main St.",
24	city: "Anchorage",
25	state: "AK",
26	zipcode: "99501",
27	},
28	},
29	},
30	},
31	},
32	{
33	insertOne: {
34	document: {
35	location: {
36	address: {
37	street1: "75 Penn Plaza",
38	city: "New York",
39	state: "NY",
40	zipcode: "10001",
41	},
42	},
43	},
44	},
45	},
46	{
47	// Update documents that match the specified filter
48	updateMany: {
49	filter: { "location.address.zipcode": "44011" },
50	update: { $set: { is_in_ohio: true } },
51	upsert: true,
52	},
53	},
54	{
55	// Delete a document that matches the specified filter
56	deleteOne: { filter: { "location.address.street1": "221b Baker St" } },
57	},
58	]);
59	// Log the result of the bulk write operation
60	console.log(result);
61	} finally {
62	// Close the database connection when the operations are completed or if an error occurs
63	await client.close();
64	}
65	}
66	run().catch(console.dir);

1	import { MongoClient } from "mongodb";
2
3	// Replace the uri string with your MongoDB deployment's connection string.
4	const uri = "<connection string uri>";
5
6	const client = new MongoClient(uri);
7
8	interface Address {
9	street1: string;
10	city: string;
11	state: string;
12	zipcode: string;
13	}
14
15	interface Theater {
16	location: { address: Address };
17	is_in_ohio?: boolean;
18	}
19
20	async function run() {
21	try {
22	const database = client.db("sample_mflix");
23	const theaters = database.collection<Theater>("theaters");
24
25	const result = await theaters.bulkWrite([
26	{
27	insertOne: {
28	document: {
29	location: {
30	address: {
31	street1: "3 Main St.",
32	city: "Anchorage",
33	state: "AK",
34	zipcode: "99501",
35	},
36	},
37	},
38	},
39	},
40	{
41	insertOne: {
42	document: {
43	location: {
44	address: {
45	street1: "75 Penn Plaza",
46	city: "New York",
47	state: "NY",
48	zipcode: "10001",
49	},
50	},
51	},
52	},
53	},
54	{
55	updateMany: {
56	// Important: You lose type safety when you use dot notation in queries
57	filter: { "location.address.zipcode": "44011" },
58	update: { $set: { is_in_ohio: true } },
59	upsert: true,
60	},
61	},
62	{
63	deleteOne: {
64	filter: { "location.address.street1": "221b Baker St" },
65	},
66	},
67	]);
68
69	console.log(result);
70	} finally {
71	await client.close();
72	}
73	}
74	run().catch(console.dir);