9 - CRUD Operations in MongoDB (Create, Read, Update, Delete)

Understanding CRUD Operations in MongoDB

MongoDB, as a NoSQL database, provides a rich set of operations for managing data. The four core operations, known as CRUD, stand for Create, Read, Update, and Delete. These operations are fundamental to interacting with data in MongoDB and form the basis for database manipulation. In this article, we’ll delve into each CRUD operation, providing examples and insights into their use.

Create (Insert) Data in MongoDB

The “C” in CRUD stands for Create, which involves inserting new data into a MongoDB collection. MongoDB provides several methods to add documents to a collection, including:

1. insertOne()

The insertOne() method adds a single document to a collection. Here’s an example:


db.myCollection.insertOne({
    "name": "Alice",
    "age": 28,
    "city": "New York"
})

2. insertMany()

The insertMany() method inserts multiple documents into a collection in a single operation. Here’s an example:


db.myCollection.insertMany([
    {
        "name": "Bob",
        "age": 32,
        "city": "Los Angeles"
    },
    {
        "name": "Charlie",
        "age": 25,
        "city": "San Francisco"
    }
])

Read (Query) Data from MongoDB

The “R” in CRUD stands for Read, which involves querying and retrieving data from a MongoDB collection. MongoDB offers a powerful query language that allows you to filter and retrieve documents based on specific criteria. Here are some common query operations:

1. find()

The find() method retrieves documents from a collection. You can specify query criteria to filter the results. Here’s an example:


// Find all users in New York
db.myCollection.find({ "city": "New York" })

2. findOne()

The findOne() method returns the first document that matches the query criteria. It’s often used when you expect a single result. Here’s an example:


// Find the first user in Los Angeles
db.myCollection.findOne({ "city": "Los Angeles" })

Update Data in MongoDB

The “U” in CRUD stands for Update, which involves modifying existing data in a MongoDB collection. MongoDB provides methods for updating documents based on specific criteria. Here are some common update operations:

1. updateOne()

The updateOne() method updates the first document that matches the query criteria. You can specify the fields to be modified. Here’s an example:


// Update the age of the first user in New York
db.myCollection.updateOne(
    { "city": "New York" },
    { $set: { "age": 29 } }
)

2. updateMany()

The updateMany() method updates all documents that match the query criteria. It allows you to apply the same update to multiple documents. Here’s an example:


// Update the age of all users in San Francisco
db.myCollection.updateMany(
    { "city": "San Francisco" },
    { $set: { "age": 26 } }
)

Delete Data in MongoDB

The “D” in CRUD stands for Delete, which involves removing data from a MongoDB collection. MongoDB provides methods for deleting documents based on specific criteria. Here are some common delete operations:

1. deleteOne()

The deleteOne() method removes the first document that matches the query criteria. Here’s an example:


// Delete the first user in Los Angeles
db.myCollection.deleteOne({ "city": "Los Angeles" })

2. deleteMany()

The deleteMany() method deletes all documents that match the query criteria. It allows you to remove multiple documents in a single operation. Here’s an example:


// Delete all users aged 25
db.myCollection.deleteMany({ "age": 25 })

CRUD Operations in Combination

CRUD operations can be combined to perform more complex tasks. For example, you can find documents that match a certain condition, update specific fields, and delete records that are no longer needed. These operations can be executed sequentially to achieve specific data manipulation tasks.

Example: Updating and Deleting Documents

In this example, we first find all documents with an age greater than 30 and then update their “status” field to “inactive.” Subsequently, we delete all “inactive” users:


// Update users with age > 30 to "inactive"
db.myCollection.updateMany(
    { "age": { $gt: 30 } },
    { $set: { "status": "inactive" } }
)

// Delete all "inactive" users
db.myCollection.deleteMany({ "status": "inactive" })

Conclusion

CRUD operations (Create, Read, Update, Delete) are essential for managing data in MongoDB. These operations empower you to add, retrieve, modify, and remove data from a MongoDB collection. By mastering CRUD operations, you gain the ability to effectively interact with your MongoDB database and perform a wide range of data manipulation tasks.

9 – CRUD Operations in MongoDB (Create, Read, Update, Delete)