Docs Menu
Docs Home
/
Languages
/
Javascript
/
Node.js
/
Usage Examples

Perform Bulk Operations

The bulkWrite() method performs batch write operations against a single collection. This method reduces the number of network round trips from your application to the server which therefore increases the throughput and performance. Bulk writes return a collection of results for all operations only after all operations passed to the method complete.

You can specify one or more of the following write operations in bulkWrite():

  • insertOne

  • updateOne

  • updateMany

  • deleteOne

  • deleteMany

  • replaceOne

The bulkWrite() method accepts the following parameters:

  • operations: specifies the bulk write operations to perform. Pass each operation to bulkWrite() as an object in an array. For examples that show the syntax for each write operation, see the bulkWrite API documentation.

  • options: optional settings that affect the execution of the operation, such as whether the write operations should execute in sequential order and the write concern.

    By default, MongoDB executes bulk write operations one-by-one in the specified order (i.e. serially). During an ordered bulk write, if an error occurs during the processing of an operation, MongoDB returns without processing the remaining operations in the list. In contrast, when ordered is false, MongoDB continues to process remaining write operations in the list. Unordered operations are theoretically faster since MongoDB can execute them in parallel, but should only be used if the writes do not depend on order.

If you create an index with a unique index constraint, you might encounter a duplicate key write error during an operation in the following format:

Error during bulkWrite, BulkWriteError: E11000 duplicate key error collection: ...

Similarly, if you attempt to perform a bulk write against a collection that uses schema validation, you may encounter warnings or errors related to the formatting of inserted or modified documents.

Example

The following code sample performs a bulk write operation on the theaters collection in the sample_mflix database. The example call to bulkWrite() includes examples of insertOne, updateMany, and deleteOne write operations:

Note

You can use this example to connect to an instance of MongoDB and interact with a database that contains sample data. To learn more about connecting to your MongoDB instance and loading a sample dataset, see the Usage Examples guide.

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

When you run the preceding example, you should see the following output:

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

Back

Watch for Changes