MongoDB

MongoDB is a popular open-source, NoSQL database management system known

for its flexibility, scalability, and ease of use. It belongs to the document-oriented

database category, meaning it stores data in a format similar to JSON (JavaScript

Object Notation) documents. Here's a brief overview of MongoDB's key features

and concepts:

1. Document-Oriented: MongoDB stores data in flexible, JSON-like documents,

making it easy to store and represent complex data structures. These

documents can vary in structure and can contain arrays and other nested

documents.

2. Schema-less Design: Unlike traditional relational databases, MongoDB

doesn't require a predefined schema for the data it stores. This provides

flexibility as fields can be added or removed from documents without

affecting other documents in the collection.

3. High Scalability: MongoDB is designed to scale horizontally, meaning it can

handle large volumes of data by distributing it across multiple servers. This

allows for high performance and scalability as the database grows.

4. Querying: MongoDB supports a powerful query language that allows for

complex queries using a variety of operators and expressions. It also

supports indexing for efficient querying of large datasets.

5. Aggregation Framework: MongoDB provides an aggregation framework that

allows for data processing and analysis within the database itself. It supports

a variety of operations such as filtering, grouping, sorting, and more.

6. Replication and High Availability: MongoDB supports replication, allowing

data to be replicated across multiple servers for fault tolerance and high

availability. It also provides automatic failover and data redundancy features

to ensure data availability in case of server failures.

7. Sharding: MongoDB supports sharding, which involves partitioning data

across multiple servers to distribute the load and improve scalability. This

allows MongoDB to handle large datasets and high write throughput.

8. Community and Ecosystem: MongoDB has a large and active community,

providing resources, tutorials, and support for users. It also has a rich

ecosystem with libraries, frameworks, and tools for integration with various

programming languages and platforms.

Overall, MongoDB is well-suited for a wide range of applications, including web,

mobile, IoT, and big data, where flexibility, scalability, and performance are key

requirements.

In MongoDB, a database is created implicitly when you first create a collection within
that database. MongoDB does not require you to explicitly create a database before
using it. When you insert data into a collection within a database that doesn't exist yet,
MongoDB automatically creates the database and the collection.

However, if you want to explicitly create a new database, you can use the use command
followed by the name of the database you want to create. Here's how you can do it
using the MongoDB shell:

use my_database

Replace my_database with the name you want to give to your database. If the database
already exists, MongoDB will switch to that database. If the database doesn't exist,
MongoDB will create it.

It's important to note that until you create at least one document within a collection in
the database, the database itself won't be visible in the list of databases. This is because
MongoDB creates databases and collections only when they are needed. Once you
insert data into a collection, the database and collection will be visible in the MongoDB
shell or any other MongoDB client.
In MongoDB, you interact with data primarily through collections, which are

analogous to tables in relational databases. Here's a brief overview of how you can

perform basic CRUD (Create, Read, Update, Delete) operations in MongoDB:

1. Inserting Documents: To insert a document into a collection, you can use the

insertOne() or insertMany() methods provided by the MongoDB driver or

client library. Here's an example of inserting a document into a collection

called users:

db.users.insertOne({ name: "John Doe", age: 30, email: "[email protected]"

});

2. Updating Documents: MongoDB provides the updateOne() and

updateMany() methods to update documents in a collection. You can specify

a filter to identify the document(s) to be updated and provide the new values

using update operators. Here's an example of updating a document in the

users collection:

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

 3. Deleting Documents: To delete documents from a collection, you can use

the deleteOne() or deleteMany() methods. Specify a filter to identify the

document(s) to be deleted. Here's an example of deleting a document from

the users collection:

db.users.deleteOne({ name: "John Doe" });

4. Querying Documents: MongoDB provides the find() method to query

documents in a collection. You can specify a filter to retrieve documents that

match certain criteria. Here's an example of querying documents from the

users collection:

// Find all documents

db.users.find();

// Find documents with a specific condition

db.users.find({ age: { $gte: 30 } });

// Find documents with projection (return only specific fields)

db.users.find({}, { name: 1, age: 1 });

These are the basic operations for interacting with MongoDB collections. MongoDB

offers many more advanced features for querying, indexing, aggregation, and

more, allowing for powerful and flexible data manipulation.

Here are 20 different queries to retrieve documents from a collection containing

sample employee documents:

1. Retrieve all documents:

db.employees.find({});

2. Retrieve documents where salary is greater than 50000:

db.employees.find({ salary: { $gt: 50000 } });

3. Retrieve documents where phone number starts with "555":

db.employees.find({ phone: /^555/ });

4. Retrieve documents where email ends with "@example.com":

db.employees.find({ email: /@example\.com$/ });

5. Retrieve documents where department is "IT":

db.employees.find({ department: "IT" });

6. Retrieve documents hired after a specific date:

db.employees.find({ hiredate: { $gt: ISODate("2022-01-01") } });

7. Retrieve documents with a specific name:

db.employees.find({ name: "John Doe" });

8. Retrieve documents where salary is between 40000 and 60000:

db.employees.find({ salary: { $gte: 40000, $lte: 60000 } });

9. Retrieve documents where phone number is not null:

db.employees.find({ phone: { $exists: true } });

10.Retrieve documents where email is not provided:

db.employees.find({ email: { $exists: false } });

11.Retrieve documents where hire date is within a specific range:

db.employees.find({ hiredate: { $gte: ISODate("2022-01-01"), $lte: ISODate("2022-

12-31") } });
 12.Retrieve documents where department is either "IT" or "HR":

db.employees.find({ department: { $in: ["IT", "HR"] } });

13.Retrieve documents where salary is not equal to 60000:

db.employees.find({ salary: { $ne: 60000 } });

14.Retrieve documents where phone number is provided and email is not:

db.employees.find({ phone: { $exists: true }, email: { $exists: false } });

15.Retrieve documents where name contains "Doe":

db.employees.find({ name: /Doe/ });

16.Retrieve documents where hire date is within the last 3 months:

db.employees.find({ hiredate: { $gte: new Date(Date.now() - 90 * 24 * 60 * 60 *

1000) } });

17.Retrieve documents sorted by salary in descending order:

db.employees.find().sort({ salary: -1 });

18.Retrieve documents with pagination (skip 10 documents and limit to 5):

db.employees.find().skip(10).limit(5);

19.Retrieve documents where salary is greater than 50000 and department is

"IT":

db.employees.find({ salary: { $gt: 50000 }, department: "IT" });

20.Retrieve documents where email is provided and hire date is within the last

year:

db.employees.find({ email: { $exists: true }, hiredate: { $gte: new Date(Date.now()

- 365 * 24 * 60 * 60 * 1000) } });

Here are some MongoDB queries with group functions:

1. Grouping by Department and Calculating Average Salary:

db.employees.aggregate([ { $group: { _id: "$department", averageSalary: { $avg:

"$salary" } } } ]);

2. Counting Number of Employees in Each Department:

db.employees.aggregate([ { $group: { _id: "$department", count: { $sum: 1 } } } ]);

 3. Finding Maximum Salary in Each Department:

db.employees.aggregate([ { $group: { _id: "$department", maxSalary: { $max:

"$salary" } } } ]);

4. Calculating Total Salary Expense for Each Department:

db.employees.aggregate([ { $group: { _id: "$department", totalSalary: { $sum:

"$salary" } } } ]);

5. Finding the Oldest Employee in Each Department (based on hire date):

db.employees.aggregate([ { $group: { _id: "$department", oldestEmployee: { $min:

"$hiredate" } } } ]);

6. Grouping by Department and Sorting by Average Salary:

db.employees.aggregate([ { $group: { _id: "$department", averageSalary: { $avg:

"$salary" } } }, { $sort: { averageSalary: -1 } } ]);

7. Calculating Salary Range for Each Department (difference between max and

min salary):
db.employees.aggregate([ { $group: { _id: "$department", minSalary: { $min:

"$salary" }, maxSalary: { $max: "$salary" } } }, { $project: { _id: 1, salaryRange: {

$subtract: ["$maxSalary", "$minSalary"] } } } ]);

8. Grouping by Department and Finding the Top 3 Highest Paid Employees in

Each Department:

db.employees.aggregate([ { $sort: { salary: -1 } }, { $group: { _id: "$department",

employees: { $push: { name: "$name", salary: "$salary" } } } }, { $project: { _id: 1,

top3Employees: { $slice: ["$employees", 3] } } } ]);

Here are 30 multiple-choice questions (MCQs) along with their answers based on

the details provided about MongoDB:

Which of the following best describes MongoDB?

a) A relational database management system

b) A document-oriented NoSQL database

c) A graph database

d) A key-value store

Answer: b) A document-oriented NoSQL database

MongoDB is known for its flexibility primarily because:

a) It enforces a strict schema for data storage

b) It allows only predefined data structures

c) It stores data in JSON-like documents

d) It doesn't support querying

Answer: c) It stores data in JSON-like documents

Which method is used to insert a single document into a MongoDB collection?

a) insertOne()

b) insert()
c) addOne()

d) create()

Answer: a) insertOne()

MongoDB supports which type of scaling?

a) Vertical scaling

b) Horizontal scaling

c) Diagonal scaling

d) Linear scaling

Answer: b) Horizontal scaling

What query operator is used to specify a greater than condition in MongoDB?

a) $gt

b) $lt
c) $gte

d) $lte

Answer: a) $gt

Which aggregation function is used to calculate the average of a numeric field in

MongoDB?

a) $avg

b) $sum

c) $max

d) $min

Answer: a) $avg

MongoDB uses which method to update documents in a collection?

a) updateOne()
b) modify()

c) change()

d) replaceOne()

Answer: a) updateOne()

MongoDB documents are similar to which data format?

a) XML

b) CSV

c) JSON

d) YAML

Answer: c) JSON

Which operator is used for logical AND operation in MongoDB queries?

a) $or
b) $not

c) $and

d) $nor

Answer: c) $and

MongoDB's aggregation framework allows for which of the following operations?

a) Sorting

b) Filtering

c) Grouping

d) All of the above

Answer: d) All of the above

How can you delete multiple documents matching a condition in MongoDB?

a) delete()
b) deleteOne()

c) remove()

d) deleteMany()

Answer: d) deleteMany()

Which query operator is used to perform pattern matching in MongoDB?

a) $in

b) $regex

c) $like

d) $pattern

Answer: b) $regex

MongoDB provides automatic failover and data redundancy features to ensure:

a) Data loss
b) Data integrity

c) Data consistency

d) Data compression

Answer: b) Data integrity

Which method is used to retrieve a single document from a MongoDB collection?

a) findOne()

b) getOne()

c) fetchOne()

d) retrieveOne()

Answer: a) findOne()

What does MongoDB use to distribute data across multiple servers for scalability?

a) Replication
b) Sharding

c) Clustering

d) Partitioning

Answer: b) Sharding

Which query operator is used to specify a less than or equal to condition in

MongoDB?

a) $gt

b) $lt

c) $gte

d) $lte

Answer: d) $lte

MongoDB's schema-less design means:

a) It enforces a strict schema for data storage

b) It requires a predefined schema for data storage

c) It doesn't require a predefined schema for data storage

d) It only supports fixed-size schemas

Answer: c) It doesn't require a predefined schema for data storage

MongoDB provides the aggregate() method to perform:

a) Data insertion

b) Data updating

c) Data querying

d) Data aggregation

Answer: d) Data aggregation

Which method is used to delete a single document from a MongoDB collection?

a) deleteOne()

b) removeOne()

c) eraseOne()

d) destroyOne()

Answer: a) deleteOne()

MongoDB supports which type of database indexing?

a) Primary indexing

b) Secondary indexing

c) Tertiary indexing

d) Quaternary indexing

Answer: b) Secondary indexing

How can you update multiple documents matching a condition in MongoDB?

a) update()

b) updateMany()

c) modifyMany()

d) changeMany()

Answer: b) updateMany()

Which of the following is true about MongoDB's replication?

a) It doesn't support replication

b) It provides automatic failover

c) It requires manual intervention for failover

d) It doesn't ensure data redundancy

Answer: b) It provides automatic failover

MongoDB's $exists operator is used to check for the existence of:

a) Collections

b) Documents

c) Fields

d) Databases

Answer: c) Fields

Which method is used to retrieve all documents from a MongoDB collection?

a) fetchAll()

b) retrieveAll()

c) find()

d) getAll()

Answer: c) find()

MongoDB's sharding is used for:

a) Vertical scaling

b) Horizontal scaling

c) Diagonal scaling

d) Linear scaling

Answer: b) Horizontal scaling

The $project stage in MongoDB aggregation pipeline is used for:

a) Sorting

b) Filtering

c) Projecting fields

d) Grouping

Answer: c) Projecting fields

MongoDB's $ne operator is used to specify:

a) Equal to condition

b) Not equal to condition

c) Greater than condition

d) Less than condition

Answer: b) Not equal to condition

Which method is used to delete all documents from a MongoDB collection?

a) remove()

b) deleteAll()

c) deleteMany()

d) deleteAllDocuments()

Answer: c) deleteMany()

MongoDB's aggregation framework is based on which concept?

a) SQL

b) MapReduce

c) Joins

d) Transactions

Answer: b) MapReduce

MongoDB's $slice operator is used for:

a) Sorting

b) Filtering

c) Limiting array elements

d) Grouping

Answer: c) Limiting array elements