MongoDB (Unit I)

PART - A

1. What is MongoDB?
a. A relational database management system
b. A NoSQL database management system
c. A programming language
d. A web server

2. In MongoDB, data is stored in which format?

a. Tables
b. Rows and columns
c. JSON-like documents
d. XML files

3. What is a database in MongoDB?

a. A collection of tables
b. A group of related documents
c. A storage location for schema design
d. A set of stored procedures

4. In MongoDB, a collection is similar to which concept in relational databases?

a. Table
b. Row
c. Column
d. Index

5. What is a document in MongoDB?

a. A database schema
b. A database query
c. A record or a row in a collection
d. An index on a field

6. Which of the following is true about MongoDB's schema design?

a. It requires predefined schemas before inserting data.
b. It enforces strict data consistency across documents.
c. It allows flexible and dynamic schema design.
d. It only supports fixed-sized collections.
7. What is denormalization in MongoDB?
a. The process of breaking down documents into smaller parts
b. The process of combining multiple collections into one
c. The process of adding redundancy for improved read performance
d. The process of normalizing data into a standard format

8. Which MongoDB feature provides horizontal scalability?

a. Sharding
b. Replication
c. Indexing
d. Aggregation framework

9. What is an index in MongoDB?

a. A unique identifier assigned to each document
b. A secondary storage location for large collections
c. A feature that speeds up the query process
d. A database backup mechanism

10. Which of the following is an example of a MongoDB query language?

a. SQL
b. JSON
c. Python
d. MongoDB Query Language (MQL)

PART - B

1. Explain the concept of NoSQL databases and how MongoDB fits into this
paradigm. Discuss the advantages and disadvantages of MongoDB compared to
traditional SQL databases.

MongoDB is a document-oriented NoSQL database that provides a flexible

and scalable approach to data storage. Unlike traditional SQL databases, MongoDB
stores data in flexible, JSON-like documents called BSON (Binary JSON), allowing
for dynamic schema design. This flexibility enables easy handling of evolving data
structures and supports agile development processes.

Advantages of MongoDB over traditional SQL databases include:

 Scalability: MongoDB scales horizontally by sharding data across multiple

servers, enabling it to handle large datasets and high traffic loads effectively.
 Flexibility: MongoDB's schema-less design allows for easy modification and
addition of fields within documents, accommodating evolving application
requirements.
 Performance: MongoDB provides high-performance read and write operations
due to its efficient indexing and automatic data distribution across multiple
servers.
 Disadvantages of MongoDB compared to traditional SQL databases are:

 Lack of ACID transactions: MongoDB sacrifices ACID (Atomicity,

Consistency, Isolation, Durability) properties for scalability and performance.
It supports atomic operations within a single document, but not across multiple
documents or collections.
 Limited joins: MongoDB does not support complex joins across multiple
collections, which can make handling complex relationships between entities
more challenging.

2. Describe the structure of a MongoDB database and explain how it differs from a
relational database. Provide examples to illustrate your answer.

In MongoDB, a database is a container for collections, which, in turn, store

individual documents. Unlike a relational database, MongoDB does not enforce a
fixed schema across all documents within a collection. Each document can have its
own structure, allowing for flexibility and accommodating varying data formats.

For example, consider a blog application. In a relational database, you would

typically define tables for users, blog posts, and comments. Each table would have
predefined columns, and relationships between tables would be established using
foreign keys.

In MongoDB, you would create a database to hold collections such as

"users," "blogPosts," and "comments." The "users" collection would store documents
representing user information, while the "blogPosts" collection would contain
documents representing blog posts. The structure of each document can vary,
allowing for different fields and nesting of data as needed. For instance, a "comments"
document within the "blogPosts" collection can contain an array of comment objects.

The flexible nature of MongoDB's document structure enables easier storage

and retrieval of data without requiring complex joins or migrations when modifying
the schema.

3. Explain the concept of sharding in MongoDB and discuss its significance in

achieving scalability. Describe the steps involved in implementing sharding in a
MongoDB cluster.

Sharding in MongoDB refers to the process of distributing data across

multiple servers (or shards) to achieve horizontal scalability. It allows MongoDB to
handle large datasets and high traffic loads by partitioning data and operations across
multiple machines.

Implementing sharding in a MongoDB cluster involves the following steps:

1. Configure the MongoDB cluster: Set up a cluster by deploying multiple MongoDB
instances across different servers. Configure the cluster to enable sharding by
designating specific servers as shard servers, config servers, and mongos routers.
2. Create the sharded collection: Select a collection that you want to shard and enable
sharding for that collection. MongoDB uses a shard key to determine how data should
be distributed across the shards.
3. Choose a shard key: Select an appropriate field or set of fields as the shard key for the
sharded collection. The shard key should distribute the data evenly across the shards
and align with the application's query patterns.
4. Enable sharding for the database: Once the shard key is defined, enable sharding for
the specific database. This step allows MongoDB to distribute data according to the
shard key across the available shards.
5. Add shards to the cluster: Add one or more shards to the cluster to increase its
capacity. MongoDB automatically balances the data distribution across the available
shards based on the defined shard key.
By following these steps, MongoDB achieves scalability by distributing data
and workload across multiple servers, enabling efficient handling of large-scale
applications.

4. Discuss the concept of schema design in MongoDB. Explain the factors to

consider and best practices for designing an effective schema in MongoDB.
Schema design in MongoDB refers to the process of defining the structure and
organization of documents within collections. While MongoDB provides flexibility in
schema design, careful consideration of factors and best practices can help create an
efficient and maintainable database schema.

Factors to consider for effective schema design in MongoDB include:

 Data access patterns: Understand the application's read and write patterns, as well as
the types of queries performed. Design the schema to align with the most frequent and
critical operations to optimize performance.
 Data relationships: Determine how different entities and documents relate to each
other. Embedding related data within a single document can improve query
performance, but be mindful of potential document growth and update implications.
 Atomicity requirements: Consider the need for atomic operations. If operations on
multiple documents require atomicity, a denormalized schema with embedded data
might not be suitable.
 Data growth and scalability: Anticipate future data growth and design the schema to
accommodate scalability requirements. Sharding and distribution strategies should
align with expected growth patterns.

Best practices for schema design in MongoDB include:

 Denormalization: Embed related data within a document to optimize read operations.

However, balance denormalization with the potential for increased write complexity
and document growth.
 Preallocating space: Consider preallocating space for document growth to minimize
performance overhead from frequent document moves.
 Indexing: Create appropriate indexes to support common query patterns and ensure
efficient data retrieval. Evaluate and adjust index strategies based on query
performance analysis.
 Avoiding sparse indexes: Sparse indexes can impact performance negatively. Use
partial indexes instead to index only the necessary fields.
 Versioning: If schema changes are expected, plan for schema versioning and
migration strategies to handle evolving application requirements.
By considering these factors and following best practices, MongoDB schema
design can lead to a performant, scalable, and maintainable database.

5. Explain the concept of document validation in MongoDB. Discuss the benefits

and limitations of using document validation and provide examples of validation
rules.

Document validation in MongoDB allows the enforcement of specific rules on

the structure and content of documents within a collection. It ensures data integrity
and consistency by validating incoming documents against predefined validation
rules.

Benefits of document validation in MongoDB include:

 Data integrity: Validation rules prevent the insertion of invalid or inconsistent data
into the database, maintaining data integrity and consistency.
 Simplified application logic: By shifting data validation to the database layer,
application code can focus on business logic, reducing complexity and potential
errors.
 Improved security: Validation rules can help guard against potential security
vulnerabilities by enforcing strict data formats or rejecting certain types of input.

Limitations of document validation in MongoDB include:

 Limited complexity: Document validation rules are relatively straightforward and

cannot express complex relationships or conditional constraints between fields.
 Performance impact: Intensive validation rules can impact insert/update performance,
especially when dealing with large datasets.

Example validation rules:

 Enforce a required field: { name: { $exists: true, $ne: "" } } ensures that the "name"
field exists and is not an empty string.
 Validate field types: { age: { $type: "int" } } validates that the "age" field is of integer
type.
 Enforce value range: { rating: { $gte: 1, $lte: 5 } } ensures that the "rating" field is
between 1 and 5 (inclusive).
  These examples demonstrate how document validation rules can be used to enforce
data integrity and consistency within a MongoDB collection.

6. Discuss the trade-offs involved in choosing between embedding and referencing

related data in MongoDB. Provide scenarios where each approach is more
suitable.
Choosing between embedding and referencing related data in MongoDB
involves trade-offs that depend on the specific requirements of the application and the
data access patterns. Consider the following scenarios:

Embedding data is more suitable when:

 Data locality is critical: If related data is frequently accessed together,

embedding the related data within a single document can optimize read
operations by minimizing the need for joins.
 Data consistency is important: Embedding ensures atomicity, as updates to a
document can be performed in a single operation. This is particularly useful
when data updates across related entities must be consistent.
 Data size is manageable: Embedding works well when the related data does
not grow excessively, ensuring that documents remain within the maximum
size limit.

Referencing data is more suitable when:

 Data is shared across multiple documents: If related data is reused by multiple

documents or collections, referencing helps avoid data duplication and ensures
consistency.
 Data needs to be updated independently: Referencing allows updates to related
data without modifying multiple documents. This approach is suitable when
updating related data independently is essential.
 Data growth is unpredictable: Referencing allows for more flexible scaling, as
the related data can reside in separate collections or even databases, allowing
for independent sharding and distribution strategies.

Choosing the appropriate approach requires careful consideration of factors

such as data access patterns, data relationships, consistency requirements, and
scalability needs. It is often a balancing act between optimizing read performance and
managing data complexity and consistency.

PART - C

7. Explain the key components of a MongoDB database and how they relate to each
other. Discuss the advantages and disadvantages of using MongoDB databases
compared to traditional relational databases.
 In MongoDB, a database is the top-level container that holds collections,
which, in turn, store individual documents. The key components of a MongoDB
database are as follows:

 Collections: Collections are analogous to tables in a relational database. They group

related documents together and provide a way to organize and manage data.
 Documents: Documents are individual records stored within a collection. They are
JSON-like structures (BSON) that consist of key-value pairs and can have nested
fields.
 Schema: MongoDB is a schema-less database, meaning that documents within a
collection do not have a fixed structure. Each document can have its own unique
schema, allowing for flexible and agile data modeling.
 Indexes: Indexes in MongoDB improve query performance by enabling efficient data
retrieval. They can be created on individual fields or combinations of fields within a
collection.

Advantages of using MongoDB databases compared to traditional relational

databases include:

 Flexible schema: MongoDB's flexible schema allows for easy handling of evolving
data structures and accommodates dynamic changes in application requirements
without the need for migrations.
 Scalability: MongoDB's architecture supports horizontal scalability through sharding,
allowing for the distribution of data across multiple servers. This enables seamless
handling of large datasets and high traffic loads.
 Performance: MongoDB's document-oriented structure and indexing capabilities
provide efficient read and write operations, resulting in improved performance for
certain types of applications and workloads.

Disadvantages of MongoDB compared to traditional relational databases are:

 Lack of ACID transactions: MongoDB sacrifices full ACID (Atomicity, Consistency,

Isolation, Durability) compliance for scalability and performance. While MongoDB
supports atomic operations at the document level, it does not provide transaction
support spanning multiple documents or collections.
 Limited support for complex joins: MongoDB's denormalized data model does not
support complex joins across multiple collections as easily as relational databases.
This can make handling complex relationships between entities more challenging.

8. Discuss the considerations and best practices for schema design in MongoDB.
Provide examples to illustrate your answer.

Schema design in MongoDB is a crucial aspect of building efficient and

scalable applications. Consider the following considerations and best practices for
schema design:
 Understand data access patterns: Analyze the application's read and write patterns to
determine the most frequent and critical operations. Design the schema to align with
these patterns to optimize performance.
 Normalize or denormalize data: Consider the relationships between entities and
whether to normalize or denormalize the data. Normalization minimizes data
redundancy but may require complex joins, while denormalization simplifies queries
but can lead to data duplication.
 Embedding vs. referencing: Decide whether to embed related data within a document
or reference it using references or manual references. Embedding improves read
performance by reducing the need for joins, while referencing reduces data
duplication and supports more complex relationships.
 Consider data growth and scalability: Anticipate future data growth and design the
schema to accommodate scalability requirements. Evaluate sharding strategies,
choose appropriate shard keys, and distribute data effectively across shards.
 Optimize indexing: Create indexes on fields that are frequently used in queries to
improve query performance. Consider compound indexes for queries involving
multiple fields and analyze the performance impact of indexes on write operations.
 Plan for schema evolution: Design the schema with future changes in mind. Plan for
versioning and migration strategies to handle evolving application requirements
without significant disruption.

Example 1:
Consider an e-commerce application. Instead of having a separate "orders" collection
and a "customers" collection, you can denormalize the data by embedding order
information within the customer document. This way, a customer document can
contain an array of embedded order objects. This design optimizes read operations for
retrieving customer and order information together, reducing the need for complex
joins.

Example 2:
For a blogging platform, you can have separate collections for "users" and "posts."
The "users" collection stores user-related information, while the "posts" collection
stores blog post documents. Each post document can contain a reference to the user
who created it, using the user's unique identifier. This design avoids data duplication
and simplifies user-related queries, but requires a separate query to retrieve user
details for a given post.

By considering these considerations and best practices, schema design in

MongoDB can lead to efficient data modeling, improved performance, and scalable
applications.

MongoDB (Unit II)

PART - A
1. Which MongoDB operator is used to perform equality checks?
a. $in
b. $eq
c. $ne
d. $exists

2. The "insertOne" command in MongoDB is used for:

a. Creating a new database
b. Inserting a single document into a collection
c. Updating an existing document
d. Deleting a document from a collection

3. The "findOne" command in MongoDB returns:

a. All documents that match a specified condition
b. The first document that matches a specified condition
c. The total count of documents in a collection
d. An error if no documents match the specified condition
Answer: b. The first document that matches a specified condition
4. Which MongoDB operator is used to perform logical AND operations?
a. $and
b. $or
c. $not
d. $nor

5. The "updateOne" command in MongoDB is used for:

a. Creating a new collection
b. Updating a single document that matches a specified condition
c. Deleting a document from a collection
d. Querying multiple documents from a collection

6. The "deleteOne" command in MongoDB is used for:

a. Creating a new database
b. Inserting a document into a collection
c. Updating an existing document
d. Deleting a single document that matches a specified condition
7. Which MongoDB operator is used to perform greater than or equal to comparisons?
a. $gt
b. $lt
c. $gte
d. $lte

8. The "find" command in MongoDB returns:

a. All documents in a collection
b. The first document in a collection
c. The total count of documents in a collection
d. Documents that match a specified condition

9. The "drop" command in MongoDB is used for:

a. Dropping a database
b. Dropping a collection
c. Dropping an index
d. Dropping a document from a collection

10. Which MongoDB operator is used to perform pattern matching using regular expressions?
a. $regex
b. $in
c. $exists
d. $text

PART - B

1. Explain the role of the `$in` operator in MongoDB. Provide an example of how it
can be used in a query.
The $in operator in MongoDB allows you to specify multiple values and match
documents where a field's value matches any of the specified values. Here's an example:

db.products.find({ category: { $in: ["electronics", "clothing"] } })

This query will return documents from the "products" collection where the "category"
field is either "electronics" or "clothing".

2. Describe the use of the `db.collection.insertOne()` method in MongoDB. Provide

an example illustrating its usage.
The db.collection.insertOne() method in MongoDB is used to insert a single
document into a collection. It takes a document as a parameter and returns information
about the operation's success. Here's an example:

db.users.insertOne({ name: "John", age: 30, email:

"[email protected]" })

This code will insert a document with the given fields ("name", "age", and "email") into
the "users" collection.

3. Explain the difference between the `db.collection.updateOne()` and

`db.collection.updateMany()` methods in MongoDB. Provide examples showcasing
their usage.
 The db.collection.updateOne() method updates a single document that matches the
specified filter, while db.collection.updateMany() updates multiple documents that match
the filter. Here are examples:

// Update a single document

db.products.updateOne({ name: "Keyboard" }, { $set: { price: 29.99 } })

// Update multiple documents

db.products.updateMany({ category: "electronics" }, { $inc: { price: 10 } })
The first example will update the price of a single document with the name
"Keyboard," setting it to 29.99. The second example will increment the "price" field by 10
for all documents in the "products" collection with the "category" field set to "electronics."

4. Discuss the purpose of the `db.collection.deleteOne()` method in MongoDB.

Provide an example demonstrating its usage.
The db.collection.deleteOne() method in MongoDB is used to delete a single
document that matches the specified filter. Here's an example:

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

This code will delete a document from the "users" collection where the "name" field
is "John."

5. Explain the concept of "upsert" in MongoDB and how it can be achieved using
the `db.collection.updateOne()` method.
"Upsert" is a combination of "update" and "insert" operations. In MongoDB, when
using the db.collection.updateOne() method, if the specified filter does not match any
document, an "upsert" can be performed to insert a new document. Here's an example:

db.products.updateOne({ sku: "123" }, { $set: { name: "New Product" } }, { upsert: true })

If a document with the "sku" field equal to "123" exists, the code will update its
"name" field to "New Product." However, if no matching document is found, a new
document will be inserted with the specified fields.

6. Discuss the use of the `db.collection.find()` method in MongoDB and explain how
it can be enhanced with additional query operators.
The db.collection.find() method in MongoDB is used to retrieve documents from a
collection that match a specified query filter. Additional query operators can be used to
enhance the querying process. For example:

db.products.find({ price: { $gt: 100 }, category: "electronics" })

In this example, the query will return documents from the "products" collection where
the "price" field is greater than 100 and the "category" field is "electronics." The $gt
operator is used to compare values and retrieve documents with a price greater than the
specified value.
 PART - C

1. Explain the concept of indexing in MongoDB. Discuss the advantages of using

indexes and provide an example of how to create an index in MongoDB.

Indexing in MongoDB involves creating an index on one or more fields of a

collection to improve query performance. Indexes allow MongoDB to locate and retrieve
documents more efficiently by providing a quick lookup mechanism. Here are the
advantages of using indexes:

 Improved query performance: Indexes reduce the number of documents that need to
be scanned by the query engine, resulting in faster and more efficient queries.
 Sorting and ordering: Indexes can be used to sort and order query results based on
specific fields, eliminating the need for manual sorting.
 Constraint enforcement: Indexes can enforce unique constraints on fields, ensuring
data integrity.
 Text search: MongoDB supports text indexes that enable efficient text search
operations.

To create an index in MongoDB, you can use the createIndex() method. Here's an
example:

db.users.createIndex({ email: 1 })

This command creates an index on the "email" field of the "users" collection. The
value 1 indicates an ascending index, while -1 would represent a descending index. By
creating an index on the "email" field, queries that involve searching or sorting based on
email will benefit from the index's improved performance.

2. Discuss the concept of sharding in MongoDB. Explain how sharding enhances

scalability and provide an example of how to enable sharding in a MongoDB
cluster.

Sharding in MongoDB is a technique for horizontally scaling data across multiple

machines or servers. It involves distributing data across different shards based on a shard
key, which determines the document's placement in the cluster. Sharding enhances
scalability by allowing data to be spread across multiple servers, enabling efficient
distribution of read and write operations. Here's how sharding enhances scalability:

 Increased storage capacity: Sharding allows data to be distributed across multiple

servers, enabling larger datasets to be accommodated.
 Improved read and write performance: By distributing data across shards, read and
write operations can be parallelized, resulting in faster query processing and improved
performance.
 Elasticity: Sharding provides the ability to add or remove shards dynamically,
allowing the cluster to scale up or down based on changing workload requirements.
  Fault tolerance: Sharding enhances fault tolerance by replicating data across multiple
shards. If one shard goes offline, the remaining shards can continue serving data.

To enable sharding in a MongoDB cluster, you need to perform the following steps:

 Start a MongoDB instance as a config server using the --configsvr option.

 Add the config server to your MongoDB cluster using the sh.addShard() command.
 Enable sharding for a specific database using the sh.enableSharding() command.
 Choose a shard key for the collection you want to shard and shard the collection using
the sh.shardCollection() command.

Here's an example of enabling sharding for a database:

sh.enableSharding("mydatabase")

This command enables sharding for the "mydatabase" database. Once sharding is
enabled, you can shard individual collections within that database using the appropriate
shard key.

MongoDB (Unit III)

PART - A

1. What is the MongoDB shell?

a. A web-based user interface for MongoDB
b. A command-line interface for interacting with MongoDB
c. A programming language used for MongoDB development
d. A graphical tool for database administration

2. Which command is used to start the MongoDB shell?

a. mongo
b. shell
c. start-mongo
d. Mongod

3. Which command is used to display all databases in MongoDB?

a. show collections
b. show databases
c. use database_name
d. db.stats()

4. How can you switch to a different database in the MongoDB shell?

a. use database_name
b. switch database_name
c. connect database_name
d. select database_name

5. Which command is used to display all collections in the current database?

a. show collections
b. show databases
c. show tables
d. show docs

6. How can you insert a document into a collection using the MongoDB shell?
a. insertOne({document})
b. createDocument({document})
c. db.collection_name.insertOne({document})
d. db.insert({document}, collection_name)
7. Which command is used to retrieve all documents from a collection in the MongoDB
shell?
a. find()
b. get()
c. retrieve()
d. getAll()

8. How can you update a document in a collection using the MongoDB shell?
a. updateOne({filter}, {update})
b. modify({filter}, {update})
c. db.collection_name.updateOne({filter}, {update})
d. db.update({filter}, {update}, collection_name)

9. Which command is used to remove a document from a collection in the MongoDB

shell?
a. deleteOne({filter})
b. remove({filter})
c. db.collection_name.deleteOne({filter})
d. db.delete({filter}, collection_name)

10. How can you exit the MongoDB shell?

a. quit()
b. exit()
c. db.exit()
d. mongoexit()

PART - B
 1. Explain the process of connecting to a MongoDB server using the MongoDB
shell. Provide the necessary steps and commands.
To connect to a MongoDB server using the MongoDB shell, follow these steps:

 Open a terminal or command prompt.

 Enter the command mongo to start the MongoDB shell.
 If your MongoDB server is running on a remote machine, use the --host flag followed
by the server's IP address or hostname.
 If authentication is required, provide the credentials using the --username and --
password flags.
 Press Enter, and you should be connected to the MongoDB server.

2. Describe the process of creating a new database in MongoDB shell. Include the
necessary commands and any optional parameters.
To create a new database in MongoDB shell, follow these steps:

 Connect to the MongoDB server using the appropriate command (as explained in
question 1).
 Use the use command followed by the name of the new database. For example, use
mydatabase.
 If you want to specify additional options like database-level authentication or
sharding, you can pass them as options to the use command.

3. Explain how to insert documents into a MongoDB collection using the MongoDB
shell. Provide an example with multiple documents.
To insert documents into a MongoDB collection using the MongoDB shell, follow these
steps:

 Connect to the MongoDB server and select the appropriate database.

 Use the db.collectionName.insertMany() command to insert multiple documents into
a collection named collectionName.
 Pass an array of documents as an argument to the insertMany() command. Each
document should be a JSON object containing the desired fields and values.
 Execute the command, and MongoDB will insert the documents into the collection.

Example:
Suppose we have a collection named users and we want to insert two documents:

db.users.insertMany([
{
"name": "John",
"age": 30,
"email": "[email protected]"
},
 {
"name": "Alice",
"age": 25,
"email": "[email protected]"
}
])

4. Explain how to insert documents into a MongoDB collection using the MongoDB
shell. Provide an example with multiple documents.
To query data from a MongoDB collection using the MongoDB shell, follow these steps:

 Connect to the MongoDB server and select the appropriate database.

 Use the db.collectionName.find() command to retrieve documents from a collection
named collectionName.
 If you want to filter the results, provide a filter condition as an argument to the find()
command. The filter condition is a JSON object specifying the desired criteria.
 If you want to project only specific fields, you can pass a projection object as a
second argument to the find() command. The projection object specifies the fields to
include or exclude.
 Execute the command, and MongoDB will return the matching documents.

Example:
Suppose we have a collection named users and we want to retrieve all documents where
the age is greater than 25, and project only the name and email fields:

db.users.find(
{ "age": { "$gt": 25 } },
{ "name": 1, "email": 1, "_id":
0}
)

5. Explain how to update documents in a MongoDB collection using the MongoDB

shell. Provide an example with an update operation.
To update documents in a MongoDB collection using the MongoDB shell, follow these
steps:

 Connect to the MongoDB server and select the appropriate database.

 Use the db.collectionName.updateMany() command to update multiple documents in
a collection named collectionName.
 Pass two arguments to the updateMany() command. The first argument is the filter
condition to select the documents to update. The second argument is an update object
specifying the modifications to apply.
 Execute the command, and MongoDB will update the matching documents according
to the specified modifications.

Example:
 Suppose we have a collection named users and we want to update all documents where
the age is greater than 30, setting their "status" field to "inactive":

db.users.updateMany(
{ "age": { "$gt": 30 } },
{ "$set": { "status":
"inactive" } }
)

6. Describe the process of removing documents from a MongoDB collection using

the MongoDB shell. Provide an example with a deletion operation.
To remove documents from a MongoDB collection using the MongoDB shell, follow
these steps:

 Connect to the MongoDB server and select the appropriate database.

 Use the db.collectionName.deleteMany() command to remove multiple documents
from a collection named collectionName.
 Pass a filter condition as an argument to the deleteMany() command. The filter
condition selects the documents to delete.
 Execute the command, and MongoDB will remove the matching documents from the
collection.
Example:
Suppose we have a collection named users and we want to remove all documents where the
"status" field is set to "inactive":
db.users.deleteMany({ "status":
"inactive" })
PART - C

1. Explain the process of performing aggregation operations in MongoDB shell.

Provide an example that demonstrates the usage of aggregation pipelines and
various stages.
Performing aggregation operations in MongoDB shell involves using
the aggregation framework, which allows you to process and analyze data in a
collection. Here's a step-by-step process along with an example:

 Connect to the MongoDB server and select the appropriate database.

 Use the db.collectionName.aggregate() command to perform an aggregation
operation on a collection named collectionName.
 Pass an array of stages as arguments to the aggregate() command. Each stage
represents a step in the aggregation pipeline and transforms the data.
 Each stage can include various operators to modify or filter the data. Common
stages include $match, $group, $project, and $sort.
 Execute the command, and MongoDB will process the data according to the
specified aggregation pipeline.
 Example:
Suppose we have a collection named orders with documents representing
customer orders. We want to calculate the total sales value for each customer.

db.orders.aggregate([
{ $group: { _id: "$customer", totalSales: { $sum: "$amount" } } },
{ $sort: { totalSales: -1 } }
])

In this example, the aggregation pipeline consists of two stages:

 The $group stage groups the orders by the "customer" field and calculates the
sum of the "amount" field for each customer.
 The $sort stage sorts the results based on the "totalSales" field in descending
order.

2. Describe the process of creating and managing indexes in MongoDB shell.

Provide an example that demonstrates the creation of an index and its usage.
Creating and managing indexes in MongoDB shell allows for efficient
querying and sorting of data. Here's a step-by-step process along with an example:

 Connect to the MongoDB server and select the appropriate database.

 Use the db.collectionName.createIndex() command to create an index on a
collection named collectionName.
 Pass a document specifying the fields and options for the index as an argument
to the createIndex() command. The fields can be specified as ascending (1),
descending (-1), or text indexes.
 Execute the command, and MongoDB will create the index on the specified
fields.

Example:
Suppose we have a collection named products with documents representing
various products. We want to create an index on the "category" field to optimize
queries related to product categories.

db.products.createIndex({ category:
1 })

In this example, the createIndex() command creates an ascending index on the

"category" field of the "products" collection.
 To utilize the created index, you can use the db.collectionName.find()
command with a query that matches the indexed field:

db.products.find({ category:
"Electronics" })

When executing this find() command, MongoDB will utilize the created index
to efficiently retrieve documents matching the specified category.

MongoDB (Unit IV)

PART - A

1. What are MongoDB Aggregations used for?

a. Grouping and counting documents in a collection
b. Sorting documents in a collection
c. Updating documents in a collection
d. Querying documents based on a specific condition

2. Which command is used to perform aggregations in MongoDB?

a. aggregate()
b. group()
c. project()
d. find()

3. Which stage in MongoDB Aggregations is used to filter documents?

a. $match
b. $group
c. $project
d. $sort

4. Which stage in MongoDB Aggregations is used to group documents by a specified field?

a. $match
b. $group
c. $project
d. $sort

5. Which stage in MongoDB Aggregations is used to reshape the documents in the

aggregation pipeline?
a. $match
b. $group
c. $project
d. $sort
6. Which stage in MongoDB Aggregations is used to sort documents?
a. $match
b. $group
c. $project
d. $sort

7. Which stage in MongoDB Aggregations is used to calculate the average, sum,

minimum, maximum, or other statistical values?
a. $match
b. $group
c. $project
d. $sort

8. Which operator is used in MongoDB Aggregations to perform arithmetic operations?

a. $add
b. $multiply
c. $divide
d. All of the above

9. Which stage in MongoDB Aggregations is used to limit the number of documents in

the result set?
a. $limit
b. $skip
c. $sort
d. $count

10. Which stage in MongoDB Aggregations is used to skip a specified number of

documents in the aggregation pipeline?
a. $limit
b. $skip
c. $sort
d. $count

PART - B

1. Explain the concept of MongoDB Aggregations and how they differ from regular
queries.
MongoDB Aggregations provide a way to process and analyze data within the
database using a flexible pipeline of stages. Unlike regular queries, which retrieve
individual documents, aggregations allow you to perform complex data
transformations, grouping, filtering, and calculations. The aggregation framework
provides a set of operators and stages that can be combined to create powerful data
processing pipelines.
 2. Describe the $match and $group stages in MongoDB Aggregations and provide
an example for each.
The $match stage filters documents based on specified criteria. For example:

db.collection.aggregate([
{ $match: { age: { $gt: 25 } } }
])

This query matches documents where the "age" field is greater than 25.

The $group stage groups documents together based on a specified key and
performs aggregations on the grouped data. For example:

db.collection.aggregate([
{ $group: { _id: "$category", total: { $sum: "$quantity" } } }
])

This query groups documents by the "category" field and calculates the total
quantity for each category.

3. Explain the $project and $sort stages in MongoDB Aggregations and provide an
example for each.
The $project stage reshapes documents, includes or excludes fields, and
computes new fields. For example:
db.collection.aggregate([
{ $project: { name: 1, age: 1, fullName: { $concat: ["$firstName", " ",
"$lastName"] } } }
])
This query projects the "name" and "age" fields from the documents and adds
a new field called "fullName" by concatenating the "firstName" and "lastName"
fields.

The $sort stage orders the output documents based on specified criteria. For
example:

db.collection.aggregate([
{ $sort: { age: -1 } }
])

This query sorts the documents in descending order of the "age" field.

4. Describe the $lookup stage in MongoDB Aggregations and provide an example.

 The $lookup stage performs a left outer join between two collections based on
specified conditions. For example:

db.orders.aggregate([
{
$lookup: {
from: "products",
localField: "productId",
foreignField: "_id",
as: "product"
}
}
])

This query performs a lookup on the "orders" collection, matching the

"productId" field with the "_id" field in the "products" collection. The result includes
the matched documents from the "products" collection as an array in the "product"
field of each document in the output.

5. Explain the $unwind and $limit stages in MongoDB Aggregations and provide
an example for each.
The $unwind stage expands an array field, creating a new document for each
element in the array. For example:
db.collection.aggregate([
{ $unwind: "$tags" }
])
This query unwinds the "tags" array field, creating a separate document for
each tag value.

The $limit stage restricts the number of documents in the output. For example:
db.collection.aggregate([
{ $limit: 10 }
])
This query limits the output to the first 10 documents.

6. Describe the $facet stage in MongoDB Aggregations and provide an example.

The $facet stage allows you to define multiple independent pipelines within a
single aggregation. For example:

db.collection.aggregate([
{
$facet: {
categoryCounts: [
{ $group: { _id: "$category", count: { $sum: 1 } } }
],
averagePrice: [
 { $group: { _id: null, avgPrice: { $avg: "$price" } } }
]
}
}
])

This query uses the $facet stage to compute two separate aggregations. The
first pipeline calculates the count of documents for each "category," and the second
pipeline calculates the average "price" across all documents.

PART - C

1. Explain the purpose and usage of the $lookup pipeline stage in MongoDB
Aggregations. Provide a detailed example of its application.
The $lookup pipeline stage in MongoDB Aggregations is used for performing
a left outer join between two collections. It allows you to combine data from multiple
collections based on specified conditions. The $lookup stage has the following syntax:

{
$lookup: {
from: <collection>,
localField: <field>,
foreignField: <field>,
as: <outputArray>
}
}

Here's a detailed example to illustrate its usage:

Suppose we have two collections, "orders" and "products." Each order
document in the "orders" collection has a "productId" field referencing a product
document's "_id" in the "products" collection. We want to retrieve all orders with
additional information about the corresponding products.

db.orders.aggregate([
{
$lookup: {
from: "products",
localField: "productId",
foreignField: "_id",
as: "productInfo"
}
}
])

In this example, we perform a $lookup stage on the "orders" collection. We

specify the "products" collection as the "from" collection and establish the
relationship between the "productId" field in the "orders" collection and the "_id"
 field in the "products" collection. The output of the $lookup stage will be stored in the
"productInfo" field of each order document.

The result of this aggregation pipeline will be a set of order documents, with
each document containing an additional "productInfo" array field. The "productInfo"
array will include the matching product document(s) based on the "productId"
reference.

2. Describe the $group and $project stages in MongoDB Aggregations and provide
a detailed example showcasing their usage together.
The $group and $project stages are essential components of MongoDB
Aggregations that enable powerful data transformations and summarizations.

The $group stage groups documents together based on a specified key and
performs aggregations on the grouped data. The $group stage has the following
syntax:

{
$group: {
_id: <expression>,
<field1>: { <accumulator1> : <expression1> },
<field2>: { <accumulator2> : <expression2> },
...
}
}

The $project stage reshapes documents, includes or excludes fields, and

computes new fields. The $project stage has the following syntax:

{
$project: {
<field1>: <1 or 0>,
<field2>: <1 or 0>,
...
}
}

Here's a detailed example demonstrating the usage of $group and $project

stages together:
Suppose we have a collection of "orders" documents, each containing
information about the customer, the order date, and the order total. We want to
calculate the total order amount for each customer and project only the customer's
name and the calculated total.
db.orders.aggregate([
{
$group: {
_id: "$customer",
 totalAmount: { $sum:
"$orderTotal" }
}
},
{
$project: {
_id: 0,
customer: "$_id",
totalAmount: 1
}
}
])

In this example, the $group stage groups the documents by the "customer"
field and calculates the sum of the "orderTotal" field as "totalAmount". The $project
stage follows, where we reshape the output documents. We exclude the default "_id"
field by setting it to 0, rename the "_id" field to "customer" using the "$_id" system
variable, and include the "totalAmount" field.

The result of this aggregation pipeline will be a set of documents, each

containing the "customer" field and the calculated "totalAmount" field, representing
the total order amount for each customer.

These examples should provide you with a comprehensive understanding of

how the $lookup, $group, and $project stages can be utilized in MongoDB
Aggregations.

MongoDB (Unit V)
PART - A
1. What does ODM stand for in the context of MongoDB?
a. Object-Database Model
b. Object-Document Mapping
c. Object-Design Mapping
d. Object-Distributed Model

2. What is the purpose of an ODM in MongoDB?

a. To perform CRUD operations in MongoDB
b. To provide an interface for executing database queries
c. To map MongoDB documents to objects in an application
d. To establish a connection to the MongoDB server

3. Which popular ODM library is commonly used with MongoDB in Node.js

applications?
a. Mongoose
b. Sequelize
c. Hibernate
d. Django

4. Which programming language is primarily associated with Mongoose?

a. JavaScript
b. Python
c. Ruby
d. Java

5. How does Mongoose facilitate schema definition in MongoDB?

a. It enforces a rigid schema structure on MongoDB collections.
b. It generates the schema automatically based on the document structure.
c. It provides a flexible and expressive schema definition API.
d. It relies on MongoDB's built-in schema inference capabilities.

6. Which of the following is NOT a Mongoose schema type?

a. String
b. Number
c. Array
d. Object

7. What is the purpose of Mongoose models in an application?

a. To define the structure and behavior of MongoDB documents
b. To handle the communication between the application and the MongoDB server
c. To enforce strict validation rules on MongoDB documents
d. To create and manage database indexes for improved performance

8. How can you perform CRUD operations using Mongoose?

a. By writing MongoDB queries directly in the application code
b. By using Mongoose's built-in methods such as save(), find(), updateOne(), and
deleteOne()
c. By executing raw SQL queries against the MongoDB server
d. By utilizing the MongoDB shell commands within the application

9. Which of the following is NOT a feature of Mongoose?

a. Middleware support for pre and post hooks
b. Built-in support for schema migrations
c. Connection pooling and reconnect functionality
d. Query population for handling document references

10. How can you establish a connection to a MongoDB server using Mongoose?
a. By using the connect() method with the MongoDB server URL
b. By executing the mongoose.connect() function with the database credentials
c. By running the mongoose.connection() function with the MongoDB connection string
d. By calling the mongoose.createConnection() method with the server details
 PART - B

1. Explain what MongoDB ODM is and discuss its advantages over traditional
MongoDB drivers.
MongoDB ODM is a library or framework that provides an abstraction layer
between MongoDB and the application code, allowing developers to work with
MongoDB using object-oriented paradigms. Its advantages over traditional MongoDB
drivers include:

 Simplified data modeling: MongoDB ODM allows developers to define data

models using classes or schemas, making it easier to map the application's data
structures to MongoDB collections.
 Data validation and type coercion: MongoDB ODM provides built-in validation
and type coercion mechanisms, ensuring that the data stored in MongoDB
complies with the defined schema.
 Relationships and associations: ODMs like Mongoose (for Node.js) provide
features to define relationships and associations between different data models,
enabling more complex querying and data retrieval operations.
 Middleware and hooks: ODMs often offer middleware and hooks functionality,
allowing developers to define pre and post-processing logic for various database
operations. This can be useful for tasks like data validation, logging, or triggering
additional actions.
 Query abstraction: ODMs provide a high-level query API that abstracts away the
details of MongoDB's query language. This simplifies the querying process and
allows developers to express complex queries using a more familiar syntax.

2. Discuss the concept of schema in Mongoose and explain how it helps in data
modeling.
In Mongoose, a schema is a blueprint or definition that defines the structure
and behavior of a MongoDB collection. It specifies the fields, their types, validation
rules, default values, and other configuration options. The schema helps in data
modeling in the following ways:

 Structure definition: With a schema, developers can define the fields and their
types, providing a clear structure for the data stored in the MongoDB collection.
This ensures consistency and makes it easier to understand the data model.
 Validation rules: Mongoose schemas support defining validation rules for each
field, such as required fields, minimum/maximum values, regular expressions, or
custom validation functions. These rules ensure that the data inserted or updated in
the collection meets the defined criteria.
 Default values: Schemas allow specifying default values for fields. When a
document is created without providing a value for a specific field, the default value
 from the schema will be assigned automatically. This helps in ensuring consistency
and avoids unnecessary data inconsistencies.
 Middleware and hooks: Mongoose schemas support defining middleware functions
and hooks that can be executed before or after specific operations (e.g., save,
update, remove). This allows developers to add custom logic for data manipulation
or perform additional actions based on specific events.
 Virtual properties: Schemas in Mongoose support virtual properties, which are
derived properties that do not persist in the database but can be accessed as if they
were real fields. Virtual properties are useful for computed values or for combining
data from multiple fields.

3. Explain the concept of population in Mongoose and how it facilitates working

with related data.
Population in Mongoose refers to the process of automatically replacing
specified paths (fields) in a document with actual documents from other collections. It
facilitates working with related data by simplifying the retrieval and manipulation of
data across different collections. Here's how it works:

 Referencing documents: In Mongoose, when defining a schema, you can specify a

field as a reference to documents in another collection using the ref option. This
establishes a relationship between the two collections.
 Population with populate(): To retrieve related documents, you can use the
populate() method provided by Mongoose. When executing a query, you can
specify the fields to populate, and Mongoose will automatically replace the
specified paths with actual documents from the referenced collection.
 Deep population: Mongoose also supports deep population, where you can
populate fields of populated documents, enabling retrieval of multiple levels of
related data. This is useful when dealing with complex relationships and nested
data structures.
 Querying and filtering related data: When working with populated fields, you can
perform queries and apply filters based on the referenced fields. Mongoose will
handle the necessary joins and filtering operations behind the scenes, making it
easier to work with related data.
 Virtual population: Mongoose provides virtual population, which allows you to
define virtual fields that are populated dynamically based on specific criteria.
Virtual population can be useful when you want to populate fields based on
conditions rather than predefining references in the schema.

4. Discuss the differences between embedded documents and document references

in MongoDB ODM.
In MongoDB ODM, there are two approaches to represent relationships
between documents: embedded documents and document references. Here are the
differences between them:

Embedded documents:
  In this approach, related data is directly nested within the parent document.
 The related data becomes part of the parent document and is stored in the same
MongoDB document.
 Embedded documents are denormalized and provide better performance for read
operations that involve retrieving the complete parent document with its related
data.
 Updates to embedded documents are atomic and don't require separate operations
to modify the related data.
 However, embedding large amounts of data or frequently changing related data can
lead to increased document size and potentially impact write performance.

Document references:

 With document references, the parent document stores a reference to the related
document in a separate collection.
 The reference can be stored as the related document's ID or any other unique
identifier.
 Document references allow for a more normalized data structure and separate
storage of related data.
 Retrieving the related data requires additional queries to fetch the referenced
documents.
 Document references are beneficial when working with large amounts of related
data or when the related data needs to be frequently updated without affecting the
parent document.
 The choice between embedded documents and document references depends on
factors like the nature of the relationship, data access patterns, performance
requirements, and scalability considerations.

5. Explain how transactions are implemented in Mongoose and discuss their

significance in ensuring data consistency.
Starting from MongoDB 4.0, Mongoose provides support for transactions,
which allow developers to perform multiple operations as a single atomic unit.
Transactions in Mongoose are implemented using the native MongoDB transactions
feature. Here's how transactions work in Mongoose:

 Starting a transaction: To start a transaction, you use the startSession() method

provided by Mongoose. This creates a new session object associated with the
transaction.
 Executing operations: Within the transaction, you can execute multiple database
operations (e.g., inserts, updates, deletes) using Mongoose's query API. These
operations are applied to the session context.
 Committing or aborting a transaction: After executing the operations, you can
choose to commit the transaction using the commitTransaction() method. This
makes the changes permanent and releases the session. If any error occurs or if you
want to discard the changes, you can use the abortTransaction() method to roll
back the transaction.
  Ensuring data consistency: Transactions are significant in ensuring data
consistency because they provide an "all-or-nothing" guarantee. If any operation
within a transaction fails, the entire transaction is rolled back, and the database
remains unchanged. This prevents partial updates or inconsistencies when multiple
operations need to be executed as a single logical unit.
 Isolation and concurrency control: Transactions also provide isolation and
concurrency control, allowing multiple transactions to work concurrently without
interfering with each other. Transactions in Mongoose use the "snapshot isolation"
level by default, which ensures that each transaction sees a consistent snapshot of
the data without being affected by concurrent changes.

6. Discuss the techniques for optimizing performance in Mongoose and MongoDB

ODM.
Optimizing performance in Mongoose and MongoDB ODM involves various
techniques. Here are some of the common approaches:
 Query optimization: Designing efficient queries is crucial for performance. Ensure
that queries are properly indexed to speed up data retrieval. Analyze the query
patterns and use Mongoose's query optimization methods like select(), sort(),
limit(), and skip() to reduce unnecessary data transfer.
 Data modeling and schema design: Carefully design your data models and schemas
to reflect the specific access patterns and requirements of your application.
Denormalize or normalize data based on query patterns and performance needs.
Use appropriate data types, indexes, and validation rules to ensure data integrity
and optimize queries.
 Indexing: Properly indexing the fields used in queries can significantly improve
query performance. Analyze the query patterns and create indexes on frequently
queried fields. Use compound indexes when necessary to cover multiple fields in a
single index.
 Caching: Implement caching mechanisms to store frequently accessed data in
memory. Tools like Redis or Memcached can be used to cache query results or
frequently accessed documents, reducing the load on the database and improving
response times.
 Connection pooling: Use connection pooling to efficiently manage database
connections and reduce connection overhead. Mongoose provides connection pool
management by default, allowing multiple requests to reuse existing connections
instead of creating new ones.
 Load balancing and scaling: When dealing with high traffic or large datasets,
consider distributing the workload across multiple MongoDB instances or replica
sets. Implement sharding to horizontally scale the database and handle increased
read and write loads.
 Monitoring and profiling: Regularly monitor the performance of your MongoDB
database using tools like MongoDB Compass or the MongoDB Monitoring and
Profiling tools. Analyze slow queries, identify bottlenecks, and optimize query
plans based on the profiling results.

PART - C
 1. Explain the concept of middleware in Mongoose and discuss its role in
implementing complex business logic and data validation.
Middleware in Mongoose refers to functions that can be executed before or
after specific operations, such as saving a document, updating a document, or removing a
document. It allows developers to add custom logic and perform additional tasks during these
operations. Here's how middleware works in Mongoose and its role in implementing complex
business logic and data validation:
 Pre and post hooks: Mongoose provides pre and post hooks that allow you to define
middleware functions to be executed before or after specific operations. For example,
you can define a pre-save middleware function that runs before a document is saved to
the database or a post-remove middleware function that executes after a document is
removed.
 Data validation: Middleware functions can be used for data validation before saving or
updating a document. You can define pre-save middleware that checks the document's
fields, applies validation rules, and ensures that the data is consistent and valid. If
validation fails, you can stop the operation or perform error handling.
 Business logic implementation: Middleware functions enable the implementation of
complex business logic in your application. For example, you can define pre-save
middleware that performs calculations or transformations on the document's fields,
updates related data, or triggers external actions based on specific conditions. This allows
you to encapsulate and centralize your business logic within the database layer.
 Error handling and data normalization: Middleware functions can handle errors and
exceptions that occur during database operations. You can define error-handling
middleware that catches and handles specific errors, logs them, and performs recovery
actions. Additionally, middleware functions can normalize the data before saving or
updating it, ensuring consistency and adherence to specific rules or formats.
 Asynchronous operations: Middleware functions in Mongoose support asynchronous
operations using promises or async/await syntax. This allows you to perform
asynchronous tasks like calling external APIs, querying other collections, or performing
complex calculations within the middleware.
 Reusability and maintainability: Middleware functions can be defined at the schema
level and reused across multiple operations or documents. This promotes code
reusability, reduces duplication, and improves the maintainability of your application's
logic.
By utilizing middleware in Mongoose, developers can implement complex business
logic, enforce data validation rules, handle errors, and perform additional tasks during
database operations, making the code more modular, maintainable, and robust.

2. Discuss the process of schema migration in Mongoose and explain how it helps in
managing changes to the database structure over time.
Schema migration in Mongoose refers to the process of managing changes to
the database structure (schemas) over time, typically when introducing modifications to
existing schemas or adding new schemas. It ensures that the database structure stays in sync
with the evolving application requirements. Here's how the process of schema migration
works in Mongoose and its benefits:
 Versioning: The first step in schema migration is versioning the schemas. Each schema is
associated with a version number, which is typically stored alongside the schema
definition. The version number represents the state of the schema at a particular point in
time.
 Changes to schemas: When a change is required in a schema, such as adding a new field,
modifying an existing field, or removing a field, the schema definition is updated
accordingly. The version number of the schema is also incremented to reflect the change.
 Migration scripts: Migration scripts are created to handle the actual migration process. A
migration script consists of logic that detects the current schema version in the database
and applies the necessary changes to bring it to the desired version.
 Upgrading the schema: When the application starts or during a deployment process, the
migration scripts are executed. They analyze the current version of the schema in the
database, compare it with the desired version, and apply the required changes
incrementally.
 Data migration: In addition to updating the schema structure, migration scripts can also
handle data migration if necessary. For example, if a new field is added, the migration
script may populate the existing documents with default values or migrate data from
other fields.
 Rollbacks and reversibility: Schema migration scripts should be designed to be
reversible. In case of errors or issues during the migration process, rollbacks can be
executed to revert the changes and restore the previous schema version.

Benefits of schema migration in Mongoose include:

 Flexibility: Schema migration allows for flexible changes to the database structure,
accommodating evolving application requirements without requiring a complete database
rebuild.
 Consistency: Schema migration ensures that the database schema is consistent across
different environments (e.g., development, staging, production) and avoids data
inconsistencies caused by manual changes.
 Maintainability: By versioning and scripting schema changes, developers can easily track
and manage database modifications, making it easier to maintain and update the
application over time.
 Collaboration: Schema migration facilitates collaboration among developers by
providing a systematic approach to managing schema changes. It allows multiple
developers to work on different aspects of the application's schema without conflicts.