Mongodb Crud Operations Insertone Insertmany Find Updateone Deleteone Complete Guide

Last Update:2025-06-23T00:00:00 .NET School AI Teacher - SELECT ANY TEXT TO EXPLANATION. 9 mins read Difficulty-Level: beginner

Understanding the Core Concepts of MongoDB CRUD Operations insertOne, insertMany, find, updateOne, deleteOne

MongoDB CRUD Operations

MongoDB is a NoSQL database that uses a flexible document model and provides various operations to manage data. The four primary operations are Create, Read, Update, and Delete, commonly known as CRUD. In MongoDB, these operations are performed using different methods. Let's delve into each operation:

1. InsertOne

insertOne is used to insert a single document into a MongoDB collection.

Syntax:

db.collectionName.insertOne({document})

Example:

db.users.insertOne({ name: "John Doe", age: 30, email: "john.doe@example.com" })

Key Points:
- Returns the _id of the inserted document if not explicitly provided.
- Useful for adding a single user, record, or item to a collection.

2. InsertMany

insertMany is used to insert multiple documents into a MongoDB collection.

Syntax:

db.collectionName.insertMany([{document1}, {document2}, ...])

Example:

db.users.insertMany([
  { name: "Jane Smith", age: 28, email: "jane.smith@example.com" },
  { name: "Alice Johnson", age: 32, email: "alice.johnson@example.com" }
])

Key Points:
- Inserts an array of documents at once.
- Efficient for adding multiple records simultaneously.
- Returns an array of inserted documents' _ids.

3. Find

find is used to query and read documents from a MongoDB collection.

Syntax:
```
db.collectionName.find({query})
```
Example:
```
db.users.find({ age: { $gt: 25 } })
```
Key Points:
- Retrieves documents that match a specified condition.
- Supports various query operators such as $gt (greater than), $lt (less than), $in (in array), $and, $or, etc.
- Can return a cursor to iterate over multiple documents if no limit is set.

4. UpdateOne

updateOne modifies a single document in a MongoDB collection that matches a given filter.

Syntax:

db.collectionName.updateOne({filter}, {update})

Example:

db.users.updateOne({ name: "John Doe" }, { $set: { age: 31 } })

Key Points:
- Updates only the first document that matches the filter.
- Uses update operators such as $set to modify fields.
- Useful for modifying specific records without affecting others.

5. DeleteOne

deleteOne removes a single document from a MongoDB collection that matches a specified filter.

Syntax:
```
db.collectionName.deleteOne({filter})
```

Example:

db.users.deleteOne({ name: "Jane Smith" })

Key Points:
- Removes the first document that matches the condition.
- Useful for deleting individual records without affecting the rest.
- Returns the status of the operation indicating if a document was deleted.

Important Information

Data Model: MongoDB is schema-less, meaning documents within the same collection can have different structures.
Indexes: Creating indexes on fields improves query performance, especially for large datasets.
Error Handling: Always handle errors in database operations to manage exceptions and ensure data integrity.
Atomicity: MongoDB provides atomic operations for individual documents, ensuring that operations are completed without interruption.
Security: Implement authentication and authorization mechanisms to secure your database from unauthorized access.

Online Code run

🔔 Note: Select your programming language to check or run code at

💻 Run Code Compiler

Step-by-Step Guide: How to Implement MongoDB CRUD Operations insertOne, insertMany, find, updateOne, deleteOne

Prerequisites

Node.js and npm: Make sure you have Node.js and npm (Node Package Manager) installed.
MongoDB: You can either have a local MongoDB server running or use MongoDB Atlas (a cloud-based MongoDB service).
MongoDB Node.js Driver: Install it by running npm install mongodb in your project directory.

Setting up the Project

First, let's set up a Node.js project and install the MongoDB driver.

mkdir mongodb-crud-example
cd mongodb-crud-example
npm init -y
npm install mongodb

Create a main.js file where we'll write our CRUD operations.

Step 1: Connect to MongoDB

Create a mongodb-crud.js file and connect to your MongoDB instance.

// Import the MongoDB client
const { MongoClient } = require('mongodb');

// Connection URL
const url = 'mongodb://localhost:27017'; // Use your MongoDB Cloud URI if needed
const client = new MongoClient(url);

// Database Name
const dbName = 'myDatabase';

// Function to connect to the database and perform operations
async function main() {
    try {
        // Connect to the MongoDB cluster
        await client.connect();

        console.log('Connected successfully to server');
        const db = client.db(dbName);
        const collection = db.collection('documents');

        // Perform CRUD operations here

    } finally {
        // Ensures that the client will close when you finish/error
        await client.close();
    }
}

main().catch(console.error);

Step 2: Insert a Single Document

Use the insertOne method to insert a single document.

const { MongoClient } = require('mongodb');
const url = 'mongodb://localhost:27017';
const client = new MongoClient(url);
const dbName = 'myDatabase';

async function main() {
    try {
        await client.connect();
        console.log('Connected successfully to server');
        const db = client.db(dbName);
        const collection = db.collection('documents');

        // Insert a single document
        const doc = { name: "John Doe", age: 30, email: "john.doe@example.com" };
        const result = await collection.insertOne(doc);

        console.log(`New document inserted with the following id: ${result.insertedId}`);

    } finally {
        await client.close();
    }
}

main().catch(console.error);

Output:

Connected successfully to server
New document inserted with the following id: <some-id>

Step 3: Insert Multiple Documents

Use the insertMany method to insert multiple documents at once.

const { MongoClient } = require('mongodb');
const url = 'mongodb://localhost:27017';
const client = new MongoClient(url);
const dbName = 'myDatabase';

async function main() {
    try {
        await client.connect();
        console.log('Connected successfully to server');
        const db = client.db(dbName);
        const collection = db.collection('documents');

        // Insert multiple documents
        const docs = [
            { name: "Jane Smith", age: 25, email: "jane.smith@example.com" },
            { name: "Sam Johnson", age: 40, email: "sam.johnson@example.com" },
            { name: "Alex Lee", age: 28, email: "alex.lee@example.com" }
        ];
        const result = await collection.insertMany(docs);

        console.log(`New documents inserted with the following ids: ${result.insertedIds}`);

    } finally {
        await client.close();
    }
}

main().catch(console.error);

Output:

Connected successfully to server
New documents inserted with the following ids: { '0': <some-id-1>, '1': <some-id-2>, '2': <some-id-3> }

Step 4: Find Documents

Use the find method to query documents. We'll demonstrate a few common queries.

Find All Documents

const { MongoClient } = require('mongodb');
const url = 'mongodb://localhost:27017';
const client = new MongoClient(url);
const dbName = 'myDatabase';

async function main() {
    try {
        await client.connect();
        console.log('Connected successfully to server');
        const db = client.db(dbName);
        const collection = db.collection('documents');

        // Find all documents
        const query = {};
        const cursor = collection.find(query);

        const documents = await cursor.toArray();

        console.log('Found documents:');
        console.log(documents);

    } finally {
        await client.close();
    }
}

main().catch(console.error);

Find Documents by Criteria

const { MongoClient } = require('mongodb');
const url = 'mongodb://localhost:27017';
const client = new MongoClient(url);
const dbName = 'myDatabase';

async function main() {
    try {
        await client.connect();
        console.log('Connected successfully to server');
        const db = client.db(dbName);
        const collection = db.collection('documents');

        // Find documents where age is greater than 30
        const query = { age: { $gt: 30 } };
        const cursor = collection.find(query);

        const documents = await cursor.toArray();

        console.log('Found documents with age > 30:');
        console.log(documents);

    } finally {
        await client.close();
    }
}

main().catch(console.error);

Output:

Connected successfully to server
Found documents with age > 30:
[
  { _id: <some-id>, name: 'Sam Johnson', age: 40, email: 'sam.johnson@example.com' }
]

Step 5: Update a Document

Use the updateOne method to update a document.

const { MongoClient } = require('mongodb');
const url = 'mongodb://localhost:27017';
const client = new MongoClient(url);
const dbName = 'myDatabase';

async function main() {
    try {
        await client.connect();
        console.log('Connected successfully to server');
        const db = client.db(dbName);
        const collection = db.collection('documents');

        // Update a document with name as 'Jane Smith'
        const filter = { name: 'Jane Smith' };
        const updateDoc = {
            $set: {
                email: 'jane.smith.updated@example.com'
            }
        };
        const result = await collection.updateOne(filter, updateDoc);

        console.log(
            `${result.matchedCount} document(s) matched the filter, updated ${result.modifiedCount} document(s)`
        );

    } finally {
        await client.close();
    }
}

main().catch(console.error);

Output:

Connected successfully to server
1 document(s) matched the filter, updated 1 document(s)

Step 6: Delete a Document

Use the deleteOne method to delete a document.

const { MongoClient } = require('mongodb');
const url = 'mongodb://localhost:27017';
const client = new MongoClient(url);
const dbName = 'myDatabase';

async function main() {
    try {
        await client.connect();
        console.log('Connected successfully to server');
        const db = client.db(dbName);
        const collection = db.collection('documents');

        // Delete a document with name as 'Alex Lee'
        const filter = { name: 'Alex Lee' };
        const result = await collection.deleteOne(filter);

        console.log(`${result.deletedCount} document(s) was/were deleted.`);
    } finally {
        await client.close();
    }
}

main().catch(console.error);

Output:

Connected successfully to server
1 document(s) was/were deleted.

Summary

In these examples, we performed the following CRUD operations using MongoDB in a Node.js environment:

Insert a Single Document (insertOne).
Insert Multiple Documents (insertMany).
Find Documents (find).
Update a Document (updateOne).
Delete a Document (deleteOne).

Top 10 Interview Questions & Answers on MongoDB CRUD Operations insertOne, insertMany, find, updateOne, deleteOne

1. What is MongoDB?

Answer: MongoDB is a cross-platform, document-oriented database program. Classified as a NoSQL database, it uses JSON-like documents with dynamic schemas (schemas-less), making the integration of data in certain applications easier and faster. It's highly scalable and is often used for handling web-scale applications with varying data models.

2. How does `insertOne` work in MongoDB?

Answer: The insertOne method is used to insert a single document into a collection in MongoDB. If the collection does not exist, insertOne will create it automatically. Example:

db.collection.insertOne({name: "John Doe", age: 34})

3. How do you use `insertMany` to add multiple documents at once?

Answer: The insertMany method allows you to insert an array of documents into a MongoDB collection. Example:

db.collection.insertMany([
    {name: "Jane Doe", age: 28},
    {name: "Jim Smith", age: 45}
])

4. What’s the purpose of the `find` method in MongoDB?

Answer: The find method is utilized to query documents from a MongoDB collection that match specified criteria. It can return one or more documents and supports many different querying techniques. Example:

// Find all documents in a collection
db.collection.find()

// Find documents matching specific fields
db.collection.find({age: {$gt: 30}})

5. How would you find a specific document using `find`?

Answer: You can retrieve a specific document by passing a filter object to the find method. To get just one document, use the findOne variant. Example:

db.collection.findOne({name: "John Doe"})

6. Can `find` return only specific fields of the documents?

Answer: Yes, you can project specific fields in the result when using find. Simply add a second argument as a projection object where fields to include are set to 1. Example:

// Return only the 'name' and '_id' fields for each document
db.collection.find({}, {name: 1})

7. How does `updateOne` allow you to modify documents in MongoDB?

Answer: The updateOne operation is used to update a single document within a collection that matches a specified filter. It takes two arguments: the filter and the update definition. Example:

db.collection.updateOne(
    {name: "John Doe"}, 
    {$set: {age: 35}}
)

In this example, we set the age field of the document with name: "John Doe" to 35.

8. Can `updateOne` be used to insert new fields into documents if they don’t exist?

Answer: Yes, updateOne can add new fields into a document if it does not already contain those fields using the $set operator. Example:

db.collection.updateOne(
    {name: "John Doe"},
    {$set: {email: "john.doe@example.com"}}
)

9. What does the `deleteOne` method do in MongoDB?

Answer: The deleteOne method removes a single document from a collection that matches the provided filter. Example:

db.collection.deleteOne({name: "Jim Smith"})

This command deletes the first document it finds with name: "Jim Smith".

10. How can I handle errors during these CRUD operations in MongoDB?

Answer: Errors in MongoDB CRUD operations can be handled using try-catch blocks. When performing operations like insertOne, insertMany, find, updateOne, deleteOne, you can catch exceptions that get thrown if something goes wrong. Example:

try {
    db.collection.insertOne({name: "Error", age: -10});
} catch (error) {
    console.log("An error occurred: ", error);
}

In Node.js applications, you typically chain .then() and .catch() methods after these operations or use async/await syntax with try-catch for async functions:

Mongodb Crud Operations Insertone Insertmany Find Updateone Deleteone Complete Guide