Delete Data from MongoDB

Deployment Type:
Client:

    Author: MongoDB Documentation Team

    In this guide, you will delete documents from a MongoDB database.

    Time required: 10 minutes

    What You’ll Need

    • Warning

      If you are running MongoDB locally and have not enabled authentication, your MongoDB instance is not secure.

    • Complete the Import Data into MongoDB guide so that there is data in your database to delete.

    Check Your Environment

    You will need to ensure that your MongoDB instance is running and accessible.

    Check that you have an Atlas account and have deployed a MongoDB database cluster. See Get Started with Atlas for information on how to login and create a cluster in Atlas.

    To make sure that your MongoDB instance is running on Windows, run the following command from the Windows command prompt:

    tasklist /FI "IMAGENAME eq mongod.exe"
    

    If a mongod.exe instance is running, you will see something like:

    Image Name                     PID Session Name        Session#    Mem Usage
    ========================= ======== ================ =========== ============
    mongod.exe                    8716 Console                    1      9,508 K
    

    To make sure your MongoDB instance is running on Mac, run the following command from your terminal:

    ps -e | grep 'mongod'
    

    If a mongod instance is running, you will see something like:

    89780 ttys026    0:53.48 ./mongod
    

    To make sure your MongoDB instance is running on Linux, run the following command from your terminal:

    ps -e| grep 'mongod'
    

    If a mongod instance is running, you will see something like:

    89780 ttys026    0:53.48 ./mongod
    

    Procedure

    1

    Connect to your MongoDB instance.

    Select the operating system platform on which you are running the MongoDB client you have selected.

    Pass the URI to the mongo shell followed by the --password option. You will then be prompted for your password.

    mongo.exe <URISTRING_SHELL_NOUSER>
    

    Pass the URI to the mongo shell followed by the --password option. You will then be prompted for your password.

    mongo <URISTRING_SHELL_NOUSER>
    

    Pass the URI to the mongo shell followed by the --password option. You will then be prompted for your password.

    mongo <URISTRING_SHELL_NOUSER>
    

    If you wish to manually configure your Compass connection, load Compass and select the New Connection link. You will see a form where you can enter connection information for MongoDB.

    Atlas users can copy a URI string from the Atlas console into Compass. MongoDB Compass can detect whether you have a MongoDB URI connection string in your system clipboard and auto- populate the connection dialog from the URI.

    See Set Up Atlas Connectivity for information on how to get the Atlas connection string URI into your copy buffer.

    If Compass was already running when you copied the URI string, click the NEW CONNECTION button.

    ../../_images/connect-to-host.png

    You will be prompted to populate the connection dialog. Click Yes.

    You should then populate the password field with the proper password for your MongoDB user in the connection form.

    Note

    Errors related to connecting through Compass will appear in red at the top of the Connect screen.

    It’s a good idea to put your connection code in a class so that it can be reused.

    from pymongo import MongoClient
    
    class Connect(object):
        @staticmethod    
        def get_connection():
            return MongoClient("<URISTRING>")
    

    If your connection_string starts with mongodb+srv, you need to install the dnspython module with

    python -m pip install dnspython
    

    Now add code to call the class you just created.

    from connect import Connect
    from pymongo import MongoClient
    
    connection = Connect.get_connection()
    

    For the MongoDB java driver 3.7 and beyond, use the MongoClients.create() method.

        final String uriString = "<URISTRING>";
        MongoClient mongoClient = MongoClients.create(uriString);
    

    For legacy drivers (prior to 3.7), use:

        final String uriString = "<URISTRING>";
        MongoClientURI uri = new MongoClientURI(uriString);
        MongoClient mongoClient = new MongoClient(uri);
    

    The MongoDB.Bson package is used in CRUD operations, so you’ll import it here.

    using System;
    using MongoDB.Bson;
    using MongoDB.Driver;
    
    namespace csharptest
    {
        class Connect
        {
            static void Main(string[] args)
            {
               var client = new MongoClient("<URISTRING>");
            }
        }
    }
    

    Replace your password and any parameters surrounded by $[] in the connection string in the code below.

    For now, you will use the context.TODO().

    Later you’ll configure the context specific to your requirements.

    client, err := mongo.Connect(context.TODO(), "<URISTRING>");
    
    if err != nil {
    	log.Fatal(err)
    }
    

    You won’t know if the connection has been successful until you use the connection. A ping is one way you can test the connection. This is a full example of a Go connection to mongoDB, including a test ping.

    package main
    
    import (
    	"context"
    	"fmt"
    	"github.com/mongodb/mongo-go-driver/mongo"
    	"log"
    )
    
    func main() {
    	// Open Connection
    	client, err := mongo.Connect(context.TODO(), "<URISTRING>");
    
    	if err != nil {
    		log.Fatal(err)
    	}
    
    	// End Open Connection Code
    
    	// Check the connection
    	err = client.Ping(context.TODO(), nil)
    
    	if err != nil {
    		log.Fatal(err)
    	}
    
    	fmt.Println("Connected to MongoDB!")
    
    }
    

    In your Go workspace and project folder, run build.

    go build
    

    Now run the binary. For binaries that are not installed, you’ll have to specify the path.

    go <path-to-yourproject>
    

    If you’d like to run the resulting binary without specifying a path, install the binary you just built into your Go workspace.

    go install
    

    Now run the code. “yourprojectname” is the name of the project directory that contains the file with your main() function.

    For installed binaries use:

    go yourprojectname
    

    For binaries that are not installed, you’ll have to specify the path.

    go ./yourprojectname
    

    The default timeout for the Go driver to connect to the database is 30 seconds. In the event that you are unable to connect, you will see an error that resembles this:

    2019/01/09 10:01:50 server selection timeout
    
    2

    Switch to the test database.

    In this guide, you will delete documents in a collection in the test database.

    To switch to the test database in the mongo shell, type

    use test
    

    If the database has not been created already, click the Create Database button.

    Screeenshot after connecting with the "Create Database" button.

    Select the test database on the left side of the Compass interface. Compass will list all of the collections in the database below the database name.

    Screenshot of the MongoDB Compass UI showing with the "test" database selected in the list of databases in the cluster.

    To access the test database:

    db = client.test
    

    Switch to the test database and access the inventory collection.

    MongoDatabase mongoDB = mongoClient.getDatabase("test");
    MongoCollection<Document> collection = mongoDB.getCollection("inventory");
    

    Within the connect block, set db to the test database.

    const db = client.db("test");
    

    To access the test database:

    db = client.test
    

    Switch to the test database and access the inventory collection.

    var database = client.GetDatabase("test");
    var collection = database.GetCollection<BsonDocument>("inventory");
    

    To access the test database:

    db := client.Database("test")
    
    3

    Delete a single document.

    The following operation deletes the first document with status equal to D:

    db.inventory.deleteOne(
        { "status": "D" } // specifies the document to delete
    )
    
    1. Copy the following filter into the Compass query bar and click Find:

      { "status" : "D" }
      
    2. Click the delete icon on the first document:

      Screenshot of the MongoDB Compass UI with a filter for all documents where the "status" field value is "D". The Delete icon is moused over for the first returned document.
    3. The document will be “Flagged for Deletion”, click Delete to confirm.

      Screenshot of the MongoDB Compass UI with a filter for all documents where the "status" field value is "D". The first document is flagged for deletion with a red bar and a button to cancel or confirm the deletion.
    db.inventory.delete_one({"status": "D"})
    
    collection.deleteOne(eq("status", "D"));
    
    db.collection('inventory').deleteOne({ 
      status: "D" 
    })
    .then(function(result) {
      // process result
    })
    
    await db.inventory.delete_one({"status": "D"})
    

    For completeness, the following example shows how you might wrap the delete one operation with the asyncio event loop:

    async def do_delete_one():
        document = await db.inventory.delete_one({"status": "D"})
        pprint.pprint(document.raw_result)
    
    var filter = Builders<BsonDocument>.Filter.Eq("status", "D");
    var result = collection.DeleteOne(filter);
    

    Before deleting the data, you’ll need to assign the inventory collection in the test database to a variable:

           coll := db.Collection("inventory")
    

    Followed by:

    	result, err := coll.DeleteOne(
    		context.Background(),
    		bson.D{
    			{"status", "D"},
    		},
    	)
    

    The operation returns a document that contains the status of the operation:

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

    The operation returns an instance of pymongo.results.DeleteResult with the status of the operation.

    The operation returns an instance of com.mongodb.client.result.DeleteResult with the status of the operation.

    The operation returns a promise that provides a result. The result.deletedCount property contains the number of documents that matched the filter.

    The operations asynchronously return instances of pymongo.results.DeleteResult with the status of the operation.

    The operation returns an instance of DeleteResult whose DeletedCount property contains the number of documents that matched the filter.

    4

    Delete multiple documents.

    The following operation deletes all of the documents in the specified inventory collection with status equal to A:

    db.inventory.deleteMany(
        { "status" : "A" } // specifies the documents to delete
    )
    

    Note

    Deleting multiple documents in Compass is a manual process. If you need to delete many documents, consider using the mongo shell or a driver.

    1. Copy the following filter into the Compass query bar and click Find:

      { "status" : "A" }
      
    2. For each document, click the delete icon:

      Screenshot of the MongoDB Compass UI with a filter for all documents where the "status" field value is "A". The Delete icon is moused over for the first returned document.
    3. The document will be “Flagged for Deletion”, click Delete to confirm.

      Screenshot of the MongoDB Compass UI with a filter for all documents where the "status" field value is "D". The first document is flagged for deletion with a red bar and a button to cancel or confirm the deletion.
    db.inventory.delete_many({"status": "A"})
    
    collection.deleteMany(eq("status", "A"));
    
    db.collection('inventory').deleteMany({ 
      status: "A" 
    })
    .then(function(result) {
      // process result
    })
    
    await db.inventory.delete_many({"status": "A"})
    

    For completeness, the following example shows how you might wrap the delete many operation with the asyncio event loop:

    async def do_delete_many():
        document = await db.inventory.delete_many({"status": "A"})
        pprint.pprint(document.raw_result)
    

    Run the loop to execute both the delete_one and delete_many operations:

    loop = asyncio.get_event_loop()
    
    tasks = [
        asyncio.ensure_future(do_delete_one()),
        asyncio.ensure_future(do_delete_many()),
    ]
    
    loop.run_until_complete(asyncio.wait(tasks))
    loop.close()
    
    var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
    var result = collection.DeleteMany(filter);
    
    	result, err := coll.DeleteMany(
    		context.Background(),
    		bson.D{
    			{"status", "A"},
    		},
    	)
    

    The operation returns a document that contains the status of the operation:

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

    The operation returns an instance of pymongo.results.DeleteResult with the status of the operation.

    The operation returns an instance of com.mongodb.client.result.DeleteResult with the status of the operation.

    The operation returns a promise that provides a result. The result.deletedCount property contains the number of documents that matched the filter.

    The operations asynchronously return instances of pymongo.results.DeleteResult with the status of the operation.

    The operation returns an instance of DeleteResult whose DeletedCount property contains the number of documents that matched the filter.

    When you are done working with your MongoDB data, close your connection to MongoDB:

    mongoClient.close();
    

    Summary

    If you have successfully completed this guide, you have deleted documents from MongoDB. That completes this introduction to CRUD operations in MongoDB.