Mongoose Queries

Mongoose is a powerful object modeling tool for MongoDB and Node.js. It provides a schema-based solution to model your data, simplifying interactions with MongoDB databases. Mongoose queries are essential for performing CRUD (Create, Read, Update, Delete) operations, making them indispensable for any database-driven application. This article covers various Mongoose queries and how to use them effectively.

What are Mongoose Queries?

Mongoose Queries are different static helper functions to carry out CRUD (Create Read Update and Delete) operations which are very important for any database. The static helper functions return a mongoose query object. The mongoose query is carried out first asynchronously and then calls the callback function passed to it. An alternative way is to use the synchronous function which is responsible for executing the query.

Mongoose queries are commonly used to:

• Retrieve documents from MongoDB (Read).
• Add new documents (Create).
• Modify existing documents (Update).
• Remove documents (Delete).

Each query function is versatile and can be customized with parameters to match specific conditions. The following example demonstrates how to use the findOneAndUpdate query to update a student's information in a MongoDB collection. Here’s the basic syntax:

Syntax:

const Student = mongoose.model('Student', studentSchema);

Student.findOneAndUpdate({ name: 'John' },
function (err, student) {
if (err) return handleError(err);
else{
// Updated successfully
}
});

Different Types of Mongoose Queries

Mongoose offers a variety of queries to interact with your MongoDB database. These queries allow us to perform CRUD (Create, Read, Update, Delete) operations efficiently. Below are the most commonly used Mongoose queries:

1. Model.deleteMany(): This query takes the parameters of any field that matches and then deletes all the entries in the database that matches.

Student.deleteMany({ age: { $gt: 18 } });

2. Model.deleteOne():  This query takes the parameters of any field that matches and then deletes any one of the entries in the database that matches.

Student.deleteOne({ name: 'John' });

3. Model.find(): This query takes the parameters of one or more fields that match and then returns all the entries in the database that matches.

Student.find({ age: { $gte: 12 } });

4. Model.findById(): This query takes the id as the parameter and then returns the entry in the database if it exists matches.

Student.findById('613b3c3d4f1a2b4dbb1b0b9f');

5. Model.findByIdAndDelete(): This query takes the id as the parameter and then deletes the entry in the database if it exists matches.

Student.findByIdAndDelete('613b3c3d4f1a2b4dbb1b0b9f');

6. Model.findByIdAndRemove(): This query takes the id as the parameter and then removes the entry in the database if it exists and then returns it to the callback function.

Student.findByIdAndRemove('613b3c3d4f1a2b4dbb1b0b9f');

7. Model.findByIdAndUpdate(): This query takes the id and the update parameters and values as the parameter and then updates the entry in the database if it exists.

Student.findByIdAndUpdate('613b3c3d4f1a2b4dbb1b0b9f', { age: 20 });

8. Model.findOne(): This query takes the parameters of any field that matches and then returns any one of the entries in the database that matches.

Student.findOne({ name: 'John' });

9. Model.findOneAndDelete(): This query takes the parameters of any field that matches and then returns and deletes any one of the entries in the database that matches.

Student.findOneAndDelete({ name: 'John' });

10. Model.findOneAndRemove(): This query takes the parameters of any field that matches and then returns and removes any one of the entries in the database that matches.

Student.findOneAndRemove({ name: 'John' });

11. Model.findOneAndReplace(): This query takes the parameters of any field and the replace document and then replaces any one of the entries in the database that matches.

Student.findOneAndReplace({ name: 'John' }, { name: 'John Doe', age: 22 });

12. Model.findOneAndUpdate(): This query takes the parameters of one or more fields and the updated fields and values and then updates any one of the entries in the database that matches.

Student.findOneAndUpdate({ name: 'John' }, { age: 21 });

13. Model.replaceOne(): This query takes the parameters as a filter and the replacement document and then replaces any one of the entries in the database that matches.

Student.replaceOne({ name: 'John' }, { name: 'John Doe', age: 22 });

14. Model.updateMany(): This query takes the parameters as a filter and the updating fields and values and then updates all of the entries in the database that matches.

Student.updateMany({ age: { $gt: 12 } }, { highschool: true });

15. Model.updateOne(): This query takes the parameters as a filter and the updating fields and values and then updates any one of the entries in the database that matches.

Student.updateOne({ name: 'John' }, { $set: { highschool: true } });

Creating Application and Using Mongoose Queries

We will create a Student model that will contain the fields name, age and date of birth. Then we will save three documents to MongoDB using mongoose. Finally, we are going to update them if their age is greater than 12. Node.js and NPM are used in this example, so it is required to be installed.

Step 1: Initialize Your Project

Start by creating a folder and initializing your Node.js project:

npm init

Step 2: Install mongoose

Install Mongoose to interact with your MongoDB database:

npm i mongoose

Project Structure: The project structure is as follows:

Example: Creating and Updating Student Records

Create a schematype, then a model, and create three different documents with some values. Then call the save function to save the document. We can create a save function to save student documents rather than creating individual documents. Then we will call a function that will query the documents having age greater than or equal to 12. We will make them study in high school as a field highschool=true.

Code:

const mongoose = require("mongoose");

// Database connection
mongoose.connect("mongodb://localhost:27017/geeksforgeeks",);

// Creating Schema
const studentSchema = new mongoose.Schema({
    name: { type: String, required: true },
    age: { type: Number, default: 8 },
    highschool: { type: Boolean, default: false },
});

// Student model
const Student = mongoose.model("Student", studentSchema);
// Creating Student document from Model

// function to save in database
const saveStudent = async (name, age) => {
    let s = new Student({
        name: name,
        age: age,
    });
    await s.save();
    console.log("student document saved in database\n
        Student name:", s.name);
};

const updateHighSchool = async () => {
    await Student.updateMany(
        { age: { $gt: 12 } }, 
        { highschool: true });
    console.log("Updated student fields");
};

const start = async () => {
    await saveStudent("Ajay", 5);
    await saveStudent("Rajesh", 13);
    await saveStudent("Manav", 15);
    updateHighSchool();
};

start();

Step 4: Run the Application

Now run the code using the following command in the Terminal/Command Prompt to run the file.

node index.js

Output:

The documents in the MongoDB are as follows: Two students are in high school but not Ajay. Previously all were set to false but two of them got updated.

Conclusion

Mongoose queries are essential for interacting with MongoDB databases. They offer a variety of methods to manage data, from creating documents to updating and deleting them. Mongoose’s flexibility in querying and updating documents allows for precise control over the data. By mastering Mongoose queries, we can efficiently handle our MongoDB operations and ensure our application works seamlessly with the database. By using Mongoose's powerful features, we can build more robust and scalable Node.js applications.