Inserting, Querying, Updating, and Deleting Documents in MongoDB

In the NoSQL ecosystem, MongoDB is renowned for its flexible document model and efficient CRUD (Create, Read, Update, Delete) capabilities. Mastering these fundamental operations is a prerequisite for building any application based on MongoDB. This article delves into how to perform data insertion, querying, updating, and deletion in MongoDB, covering everything from basic shell commands to common JavaScript driver APIs, helping developers establish a clear mindset for data management.
In MongoDB, "Create" corresponds to the Insert operation. Since MongoDB is a document-oriented database rather than a table-based one, the concept of inserting multiple rows at once found in traditional relational databases does not exist; instead, documents are inserted one by one or in batches.

MongoDB offers several methods for insertion, with insertOne, insertMany, and direct API calls at the driver level being the most common and efficient. Here is a typical JavaScript (Node.js) example:

const { MongoClient } = require('mongodb');

// Connect to the database and execute operations
async function main() {
    const client = new MongoClient("mongodb://localhost:27017");
    
    try {
        await client.connect();
        const db = client.db("myDatabase");
        
        // Insert a single document (insertOne)
        const userDoc = { name: "Alice", age: 30, email: "alice@example.com" };
        const result1 = await db.collection("users").insertOne(userDoc);
        console.log(`Generated ID: ${result1.insertedId}`);

        // Batch insert multiple documents (insertMany)
        const usersList = [
            { name: "Bob", age: 25 },
            { name: "Charlie", age: 30, active: true }
        ];
        await db.collection("users").insertMany(usersList);

    } finally {
        await client.close();
    }
}
main().catch(console.error);

During the insert operation, MongoDB automatically generates a unique _id (primary key) for each document. If this field is not specified, the database defaults to using an ObjectId. Furthermore, MongoDB can perfectly handle complex document structures containing nested objects or arrays without requiring the intricate table relationship designs necessary in relational databases.

Querying Data: Flexible Data Retrieval Strategies

"Read" is one of MongoDB's most powerful features. Benefiting from its flexible query language, developers can perform precise matches or fuzzy searches based on specific fields, combined conditions, or even regular expressions. Operators like $match, $and, and $or in MongoDB provide a level of flexibility that far exceeds the limitations of traditional SQL.

In practical development, we typically use the find() method to execute queries:

// Find all users with name "Alice"
const aliceUsers = await db.collection("users").findOne({ name: "Alice", age: { $gt: 29 } });

// Combined condition query (AND)
const activeOldUsers = await db.collection("users")
    .find({ 
        status: "active", 
        createdAt: { $gte: new Date('2023-01-01') },
        age: { $lte: 45 } 
    })
    .toArray();

// Use regular expressions for fuzzy matching on email
const regexEmail = /example\.com/;
const matchingUsers = await db.collection("users")
    .find({ email: new RegExp(regexEmail) })
    .limit(10); // Limit the number of returned results to improve performance

When querying, it is crucial to pay attention to the use of indexes. While MongoDB creates an index on _id by default, it is recommended to manually create indexes for frequently queried fields (such as name, email) to enhance retrieval speed. Additionally, for large datasets, properly utilizing .limit(), .skip(), and projection operators like $project to return only the necessary fields is a key strategy for performance optimization.

Updating and Modifying: Precise Data Changes

"Update" corresponds to the Update operation. MongoDB's update mechanism is extremely powerful, supporting conditional updates and atomic operations to ensure data consistency in concurrent scenarios. The most common methods are updateOne, updateMany, and $set or $inc operators within aggregation pipelines.

// Modify a field in a single record based on ID (atomic update)
const updatedDoc = await db.collection("users")
    .findOneAndUpdate(
        { _id: ObjectId("507f191e810c19729de860ea"), name: "Alice" }, // Query condition
        { $set: { email: "newemail@example.com", age: 31 } }         // Update operator
    );

// Batch modify multiple records (e.g., set all users older than 45 to inactive)
await db.collection("users")
    .updateMany(
        { age: { $gt: 45 } }, 
        { $set: { status: "inactive" } }
    );

// Atomic increment operation (e.g., increase inventory quantity by one)
const stockResult = await db.collection("inventory")
    .findOneAndUpdate(
        { sku: "SKU-001", inStock: true }, 
        { $inc: { quantity: -1 } }, // $inc is used for numeric increment or decrement
        { upsert: false, returnDocument: 'after' }
    );

It is worth noting that update operations in MongoDB are atomic by default. This means that even if the network fails, the transaction will rollback. If your business logic is complex and requires coordinated modifications across multiple tables or documents, it is strongly recommended to use MongoDB's transaction features to guarantee data consistency.

Deleting and Cleaning: Maintaining Data Health

"Delete" corresponds to the Delete operation. Timely cleanup when data is no longer needed or errors occur is key to maintaining database performance. MongoDB provides deleteOne, deleteMany, and operators like $currentDate in aggregation pipelines to handle document removal and field resetting.

// Delete a single matching record (returns the deleted document)
const deletedDoc = await db.collection("users")
    .findOneAndDelete({ name: "Alice" }); // Finds first then deletes, returning result containing original data

// Batch delete multiple records
await db.collection("logs").deleteMany({ createdAt: { $lt: new Date('2023-01-01') } });

// Use aggregation pipeline for complex cleanup (e.g., remove all records where age > 80)
const pipeline = [
    { $match: { age: { $gt: 80 } } },
    { $set: { deletedAt: new Date() } } // Marks deletion time rather than physically deleting immediately
];

// Note: The above example demonstrates logical marking. To truly remove from the collection, use deleteMany

When executing large-scale delete operations (such as deleteMany), it is imperative to verify that the query conditions are accurate to avoid accidentally deleting critical business data. Furthermore, regularly cleaning up historical logs or temporary files is an indispensable part of operations work; MongoDB's soft delete mechanism combined with archiving strategies effectively balances storage costs and data security.