Comprehensive Guide to MongoDB db.collection.deleteMany Method
Understanding db.collection.deleteMany() in MongoDB
The db.collection.deleteMany() method is used to delete multiple documents from a MongoDB collection that match a given filter. If no filter is provided, all documents in the collection will be deleted. This method is ideal for batch deletions where multiple records meet specific criteria.
Syntax:
db.collection.deleteMany( <filter>, { writeConcern: <document>, collation: <document> } )
Parameters:
Parameter | Type | Description |
---|---|---|
filter | Document | A query document specifying the criteria for documents to delete. To delete all documents, use an empty document {}. |
writeConcern | Document (Optional) | Specifies the level of acknowledgment requested from the server for the write operation. Example: { w: 1, j: true }. |
collation | Document (Optional) | Allows for locale-specific string comparisons, such as case sensitivity. Example: { locale: "en", strength: 2 }. |
hint | Document or String (Optional) | Specifies the index to use for the delete operation. Example: { field1: 1 } or "field1_1". |
Behavior
Time Series Collections
db.collection.deleteMany() throws a WriteError exception if used on a time series collection. To remove all documents from a time series collection, use db.collection.drop().
Delete a Single Document
To delete a single document, use db.collection.deleteOne() instead.
Alternatively, use a field that is a part of a unique index such as _id.
Transactions
db.collection.deleteMany() can be used inside distributed transactions.
Do not explicitly set the write concern for the operation if run in a transaction. To use write concern with transactions, see Transactions and Write Concern.
Examples:
Delete All Documents Matching a Condition
Code:
// Delete all documents where the 'status' field is 'inactive'
db.users.deleteMany(
{ status: "inactive" } // Filter: Match all documents with status 'inactive'
)
Explanation:
- The filter { status: "inactive" } matches all documents with the status field set to "inactive".
- All matching documents are deleted.
Delete All Documents in a Collection
Code:
// Delete all documents from the 'users' collection
db.users.deleteMany({})
Explanation:
- The empty filter {} selects all documents in the users collection for deletion.
- Use this operation with caution as it clears the collection.
Delete Documents Using Collation for Case Insensitivity
Code:
// Delete all documents with case-insensitive matching
db.products.deleteMany(
{ category: "electronics" }, // Filter: Match all documents with category 'electronics'
{
collation: { locale: "en", strength: 2 } // Collation: Case-insensitive comparison
}
)
Explanation:
- The collation { locale: "en", strength: 2 } ensures case-insensitive matching, treating "Electronics" and "electronics" as equal.
Specify Write Concern for the Operation
Code:
// Delete all documents with specific write concern
db.orders.deleteMany(
{ orderStatus: "cancelled" }, // Filter: Match all cancelled orders
{
writeConcern: { w: 1, j: true } // WriteConcern: Acknowledge the write and ensure journaling
}
)
Explanation:
- The writeConcern parameter ensures that the deletion is acknowledged and journaled.
Delete Documents Using an Index Hint
Code:
// Use a specific index for the delete operation
db.logs.deleteMany(
{ timestamp: { $lt: new Date("2023-01-01") } }, // Filter: Match logs before a specific date
{
hint: { timestamp: 1 } // Hint: Use the 'timestamp' index
}
)
Explanation:
- The hint parameter specifies the use of the timestamp index to optimize the delete operation.
Returned Output
The db.collection.deleteMany() method returns a document that indicates the outcome of the operation.
{ acknowledged: true, // Indicates if the write was acknowledged deletedCount: 5 // Number of documents deleted }
Use Cases
- Remove outdated or invalid records from a collection.
- Delete old logs or historical data beyond a certain date range.
- Clear specific data for reinitialization while retaining the collection structure.
- Combine multiple deleteMany operations within a transaction for consistency.
1. Batch Cleanup
2. Archival of Data
3. Data Reset
4. Bulk Operations in Transactions
Error Scenarios
No Matching Documents Found
Code:
db.products.deleteMany(
{ category: "nonexistent" } // Filter: No documents match this category
)
Output:
{ acknowledged: true, deletedCount: 0 // No documents were deleted }
Invalid Filter Syntax
db.users.deleteMany( { $invalidOperator: "value" } // Invalid filter )
Error:
Error: unknown operator $invalidOperator
Solution:
- Verify the filter syntax and use valid MongoDB query operators.
Best Practices
- Avoid an empty filter ({}) unless you intend to delete all documents in the collection.
- Set writeConcern: { j: true } to ensure the deletion is safely logged in the journal.
- Use a find() query to preview the documents that match the filter criteria.
- Use the hint parameter to optimize performance for large datasets.
- Apply collation to handle case-insensitive or language-aware comparisons.
1. Use Specific Filters
2. Enable Journaling for Critical Deletions
3. Test Filters Before Deleting
4. Leverage Index Hints for Performance
5. Use Collation for Locale-Specific Matching
Comparison with Related Methods
Method | Description |
---|---|
deleteOne | Deletes a single document matching the filter. |
deleteMany | Deletes all documents matching the filter. |
findOneAndDelete | Finds a single document matching the filter, deletes it, and returns the deleted document. |
It will be nice if you may share this link in any developer community or anywhere else, from where other developers may find this content. Thanks.
https://www.w3resource.com/mongodb/mongodb-db-collection-deletemany.php
- Weekly Trends and Language Statistics
- Weekly Trends and Language Statistics