Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://www.geeksforgeeks.org/mongodb/mongodb-delete-multiple-documents-using-mongoshell/ below:

MongoDB - Delete Multiple Documents Using MongoDB Shell

Last Updated : 12 Jul, 2025

MongoDB provides powerful and flexible methods for managing data, including the ability to delete multiple documents efficiently. The db.collection.deleteMany() method allows users to remove multiple documents that match a specified filter, making it an essential tool for database maintenance and data manipulation.

In this article, we will cover everything you need to know about deleting multiple documents in MongoDB, from basic syntax to advanced filtering techniques. This guide is structured to help us understand how to use deleteMany() effectively, its performance implications, and best practices to ensure smooth database operations

The db.collection.deleteMany() method is used to delete multiple documents from a collection that match a specified filter in Mongo Shell. Unlike deleteOne(), which removes only a single document, deleteMany() can remove multiple documents at once, making it ideal for bulk deletions. This method can be used in multi-document transactions. If we use this method in a capped collection, then it will throw an exception.

• Deletes multiple documents that match a specified filter.
• Returns a result containing the number of deleted documents.
• Cannot be used on capped collections.
• Supports write concern and collation options.

Syntax

db.collection.deleteMany(
    <filter>,
   {
      writeConcern: <document>,
     collation: <document>
   }
)

• filter: First parameter of this method which Specifies the selection criteria for deletion using query operators. If an empty document {} is passed, all documents in the collection will be deleted.

• writeConcern: It Defines the write concern level for the operation
  
• collation: It specifies the use of the collation for operations. It Allows specifying language-specific string comparison rules (useful for case-insensitive or locale-based matching).

The method returns a document containing:

• acknowledged - true if the write concern is enabled, false otherwise.
  
• deletedCount - The total number of documents deleted.

We have a MongoDB database named GeeksforGeeks, which contains a collection called contributors. This collection stores details about contributors in the form of documents with the following structure:

• Database: GeeksforGeeks
• Collection: contributor
• Document: four documents that contain the details of the contributors in the form of field-value pairs.

In this example, we are deleting multiple documents from the contributor collection that match the filter, i.e., language: "C#".

db.contributors.deleteMany({ language: "C#" });

Output:

• The query { language: "C#" } matches two documents.
• Both matching documents are deleted.
• The operation returns deletedCount: 2, confirming that two documents were removed successfully.

In this example, we are deleting all the documents from the contributor collection by passing empty documents in the db.collection.deleteMany() method.

db.contributor.deleteMany({})

Output

• Since the filter is {}, it matches all documents.
  
• Every document in the contributors collection is deleted.
  
• The output confirms the number of deleted documents.

Warning: This operation removes all documents permanently. If you need to clear a collection but keep its structure, use deleteMany({}) instead of drop(), which removes the collection entirely.

We can use query operators to refine deletions. Let's delete all contributors whose _id is greater than 2.

db.contributors.deleteMany({ _id: { $gt: 2 } });

Output:

{ "acknowledged" : true, "deletedCount" : 2 }

Explanation:

• The condition { _id: { $gt: 2 } } selects documents where _id is greater than 2.
  
• Two matching documents are found and deleted.
  
• The operation confirms deletion with deletedCount: 2.

When using the deleteMany() method in MongoDB, it's crucial to ensure that only the intended documents are removed to prevent accidental data loss. Implementing best practices can help maintain data integrity and improve query efficiency.

• If you don’t provide a filter, all documents will be deleted.
• Example of an unsafe query:

  db.users.deleteMany({});  // Deletes ALL users!

• If you're deleting based on a field like userID, ensure an index exists to speed up deletion.

• Run a find query first to verify the documents before deleting:

  db.contributors.find({ language: "C#" });

• Then execute deleteMany() only when sure.

• Specify a write concern to ensure data consistency.
• Example:

  db.orders.deleteMany({ status: "Cancelled" }, { writeConcern: { w: "majority" } });

• To perform case-insensitive deletions:

db.users.deleteMany(
  { name: "john doe" },
  { collation: { locale: "en", strength: 2 } }
);

The deleteMany() method is an essential tool in MongoDB for bulk deletion of documents based on various filters. Understanding its syntax, behavior, and best practices helps in efficiently managing databases without accidental data loss. By following optimized query patterns, utilizing indexes, and testing queries before execution, you can ensure safe and effective deletions in MongoDB. With these examples and techniques, you now have a comprehensive understanding of how to delete multiple documents using MongoDB Shell

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4