Bulk Operations

Sample Data

The examples in this guide use the movies and users collections in the sample_mflix database, which is included in the Atlas sample datasets. To learn how to create a free MongoDB Atlas cluster and load the sample datasets, see the Get Started with Atlas guide.

Collection Bulk Inserts

To perform a bulk insert operation on your collection, create an InsertOneModel for each operation. Then, call the bulkWrite() method on your collection and pass an array of models as a parameter. To create an InsertOneModel, specify the model's document field and set it to the document you want to insert.

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

Client Bulk Inserts

To perform a bulk insert operation across multiple collections or databases, create a ClientBulkWriteModel for each operation. Then, call the bulkWrite() method on your client and pass an array of models as a parameter.

The following table describes the fields that you can set in a ClientBulkWriteModel to specify an insert operation:

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

Collection Bulk Replacements

To perform a bulk replace operation on your collection, create a ReplaceOneModel for each operation. Then, call the bulkWrite() method on your collection and pass an array of models as a parameter.

The following table describes the fields that you can set in a ReplaceOneModel:

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

Client Bulk Replacements

To perform a bulk replace operation across multiple collections or databases, create a ClientBulkWriteModel for each operation. Then, call the bulkWrite() method on your client and pass an array of models as a parameter.

The following table describes the fields that you can set in a ClientBulkWriteModel to specify a replace operation:

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

Collection Bulk Updates

To perform a bulk update operation on your collection, create an UpdateOneModel or UpdateManyModel for each operation. Then, call the bulkWrite() method on your collection and pass an array of models as a parameter. An UpdateOneModel updates only one document that matches a filter, while an UpdateManyModel updates all documents that match a filter.

The following table describes the fields you can set in an UpdateOneModel or UpdateManyModel:

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

Client Bulk Updates

To perform a bulk update operation across multiple collections or databases, create a ClientBulkWriteModel for each operation. Then, call the bulkWrite() method on your client and pass an array of models as a parameter.

The following table describes the fields you can set in a ClientBulkWriteModel to specify an update operation:

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

Collection Bulk Deletes

To perform a bulk delete operation on your collection, create a DeleteOneModel or DeleteManyModel for each operation. Then, call the bulkWrite() method on your collection and pass an array of models as a parameter. A DeleteOneModel deletes only one document that matches a filter, while a DeleteManyModel deletes all documents that match a filter.

The following table describes the fields you can set in a DeleteOneModel or DeleteManyModel:

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

Client Bulk Deletes

To perform a bulk delete operation across multiple collections or databases, create a ClientBulkWriteModel for each operation. Then, call the bulkWrite() method on your client and pass an array of models as a parameter.

The following table describes the fields you can set in a ClientBulkWriteModel to specify a delete operation:

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

BulkWriteResult

The Collection.bulkWrite() method returns a BulkWriteResult object, which provides information about your bulk operation.

The following tables describes the fields of a BulkWriteResult object:

ClientBulkWriteResult

The MongoClient.bulkWrite() method returns a ClientBulkWriteResult object, which includes information about the client bulk write operation.

The following tables describes the fields of a ClientBulkWriteResult object:

Collection Bulk Write Exceptions

If any bulk write operations called on a collection are unsuccessful, the Node.js driver throws a MongoBulkWriteError and does not perform any further operations if the ordered option is set to true. If ordered is set to false, it will attempt to continue with subsequent operations.

A MongoBulkWriteError object contains the following properties:

Client Bulk Write Exceptions

If any bulk write operations called on your client are unsuccessful, the Node.js driver generates a MongoClientBulkWriteError. By default, the driver does not perform any subsequent operations after encountering an error. If you pass the ordered option to the bulkWrite() method and set it to false, the driver continues to attempt the remaining operations.

A MongoClientBulkWriteError object contains the following properties:

API Documentation

To learn more about any of the methods or types discussed in this guide, see the following API documentation:

• Collection.bulkWrite()

• MongoClient.bulkWrite()

• BulkWriteResult

• ClientBulkWriteResult

• ClientBulkWriteModel

• InsertOneModel

• InsertOne

• ReplaceOne

• ReplaceOneModel

• UpdateOne

• UpdateMany

• UpdateOneModel

• DeleteOne

• DeleteMany

• DeleteOneModel