Introduction To MongoDB

Chapter 1
Introduction to MongoDB
Introduction to MongoDB
MongoDB is a powerful, open-source, NoSQL (Not Only SQL) database management system
designed to handle large volumes of unstructured data. Developed by MongoDB Inc. and first
released in 2009, it provides a high-performance, scalable, and flexible alternative to traditional
relational databases such as MySQL or PostgreSQL. MongoDB is widely adopted in modern web,
mobile, and cloud-based applications due to its ease of use, rich feature set, and robust support for
modern development environments.

Key Characteristics of MongoDB

1. Document-Oriented Storage:
Unlike relational databases that store data in tables and rows, MongoDB stores data in
flexible, JSON-like documents (in BSON format). Each document can have a different
structure, allowing more flexibility in representing complex data models.
2. Schema-less Design:
MongoDB collections do not enforce a strict schema, enabling developers to modify the
structure of documents without affecting existing data. This feature is particularly useful in
agile and rapidly changing development environments.
3. Scalability:
MongoDB supports horizontal scaling through a technique known as sharding, which allows
the database to distribute data across multiple servers or nodes. This ensures the application
can handle massive amounts of data and high throughput demands.
4. High Performance:
MongoDB delivers high read and write throughput due to its efficient data storage and
indexing mechanisms. It supports in-memory computing, indexing, and aggregation pipelines
for fast and efficient data processing.
5. Rich Query Language:
MongoDB provides a powerful and expressive query language that supports CRUD (Create,
Read, Update, Delete) operations, as well as advanced features such as filtering, sorting, joins
(via $lookup), and aggregation.
6. Built-in Replication:
MongoDB ensures data availability and fault tolerance through replica sets, which are groups
of MongoDB servers that maintain the same data set. If the primary server fails, one of the
secondary servers automatically takes over.
7. Integration with Modern Applications:
MongoDB has drivers for all major programming languages including Python, JavaScript
(Node.js), Java, C#, and more. It integrates well with modern frameworks and cloud
platforms, making it an excellent choice for web and mobile development.

Architecture Overview
MongoDB's architecture revolves around the following core components:

Dept. of CS&E, MIT Mysore 2024-2025 1

Introduction To MongoDB
 Database: A physical container for collections.
 Collection: A group of MongoDB documents, similar to a table in relational databases.
 Document: A set of key-value pairs (like a JSON object), representing individual records.

MongoDB stores data in a binary format called BSON (Binary JSON), which extends the JSON
format with additional data types like date, int, and decimal.

Use Cases of MongoDB

MongoDB is suitable for a wide range of applications including:

 Real-time analytics and data processing

 Content management systems (CMS)
 Internet of Things (IoT) platforms
 Mobile and social media applications
 Product catalogs and e-commerce platforms

Advantages of MongoDB

 Flexible and dynamic data modeling

 Easy to scale and deploy in distributed environments
 Rapid development with fewer data modeling constraints
 Native support for cloud-based infrastructure
 Active community and strong enterprise support

Dept. of CS&E, MIT Mysore 2024-2025 2

Introduction To MongoDB

Chapter 2

MongoDB and the Document Model

MongoDB is a modern, NoSQL, document-oriented database that revolutionizes how data is stored,
managed, and retrieved. Unlike traditional relational databases that rely on structured schemas and
tabular data, MongoDB uses a flexible document model that aligns closely with how developers
build applications today. This model offers significant advantages in terms of scalability,
performance, and ease of development, particularly in dynamic environments.

Understanding the Document Model

At the core of MongoDB is the document data model, which stores data in BSON (Binary JSON)
documents. These documents are analogous to JSON objects and consist of key-value pairs. Each
document can contain nested structures, arrays, and fields of different data types, allowing complex
and hierarchical data to be represented naturally and efficiently.

1. Structure of a Document
A typical MongoDB document looks like this:

json
Copy code
{
"_id": "12345",
"name": "Alice Smith",
"email": "[email protected]",
"age": 29,
"address": {
"street": "123 Main Street",
"city": "New York",
"zip": "10001"
},
"hobbies": ["reading", "traveling", "coding"]
}
This document:

 Is self-contained and schema-flexible.

 Contains nested fields (e.g., address) and arrays (e.g., hobbies).
 Includes an _id field, which uniquely identifies the document within a collection.

Dept. of CS&E, MIT Mysore 2024-2025 3

Introduction To MongoDB
2. Collections and Databases
Documents are grouped into collections, which are the MongoDB equivalent of tables in relational
databases. However, unlike tables, collections do not enforce a uniform schema. Different
documents within a single collection can have varying sets of fields.

 Database: A container for collections.

 Collection: A group of related documents.
 Document: The basic unit of data in MongoDB.

This hierarchy allows for high flexibility and efficient organization of data.

Advantages of the Document Model

a. Schema Flexibility
MongoDB does not enforce a rigid schema, which means:

 Fields can be added or removed from documents at any time.

 Each document can be customized to represent specific use cases or data requirements.
 Ideal for applications with rapidly evolving data models.

b. Natural Mapping to Programming Languages

Since MongoDB documents resemble JSON objects, they map easily to native data structures in
most programming languages. This simplifies application development and eliminates the need for
complex Object-Relational Mapping (ORM).

c. Embedding and Relationships

MongoDB encourages embedding related data within documents, reducing the need for joins. For
example, a user's orders can be embedded directly in the user document. However, it also supports
references when embedding would lead to excessive document growth.

d. Performance
By storing all related data in a single document, MongoDB reduces the number of read operations.
This results in faster queries and efficient data retrieval, especially for read-heavy workloads.

Design Considerations in the Document Model

While the document model provides flexibility, certain best practices should be followed:

 Use embedding when data is accessed together frequently and doesn’t grow unbounded
(e.g., user profile and preferences).
 Use referencing when data is large, shared across documents, or updated frequently (e.g.,
product catalog and orders).
 Avoid excessive nesting and large arrays that can slow down query performance.

Example Use Case

Consider a blog application:

Relational Model:

Dept. of CS&E, MIT Mysore 2024-2025 4

Introduction To MongoDB
 users table
 posts table
 comments table

MongoDB Document Model:

json
Copy code
{
"username": "blogger101",
"email": "[email protected]",
"posts": [
{
"title": "Introduction to NoSQL",
"content": "NoSQL databases offer...",
"comments": [
{ "user": "reader1", "text": "Great post!" },
{ "user": "reader2", "text": "Very helpful, thanks!" }
]
}
]
}
This example illustrates how embedding posts and comments into a single document can simplify
the data model and enhance performance.

Fig 1. MongoDB and the Document Model

Dept. of CS&E, MIT Mysore 2024-2025 5

Introduction To MongoDB

Chapter 3
Connecting to a MongoDB Database
Establishing a connection to a MongoDB database is a crucial step in developing any application
that relies on MongoDB for data storage and retrieval. MongoDB supports various connection
methods, depending on whether the database is hosted locally or on a cloud platform such as
MongoDB Atlas. The connection process typically involves using a MongoDB connection URI,
which contains the necessary credentials and configuration to link an application to the database
server.

1. MongoDB Connection URI

A MongoDB URI (Uniform Resource Identifier) is a standardized string that provides the
connection details. The basic structure of a URI is as follows:

php-template
Copy code
mongodb://<username>:<password>@<host>:<port>/<database>?options
For example, connecting to a local MongoDB database might use:

bash
Copy code
mongodb://localhost:27017/mydatabase
In a cloud environment like MongoDB Atlas, the URI would look like:

bash
Copy code
mongodb+srv://<username>:<password>@cluster0.mongodb.net/mydatabase?retryWrites=true&w=majority
This format enables secure, customizable, and scalable access to the database from any compatible
client or programming language.

Dept. of CS&E, MIT Mysore 2024-2025 6

Introduction To MongoDB
2. Connecting to a Local MongoDB Server
When MongoDB is installed on a local system, connecting to it is straightforward. Developers can
use the MongoDB shell, command-line tools, or programming languages with MongoDB drivers.

Using MongoDB Shell:

bash
Copy code
mongo
This command opens the MongoDB shell and connects to the default local database server
(localhost:27017).

Using Python (with PyMongo):

python
Copy code
from pymongo import MongoClient

# Establish connection
client = MongoClient("mongodb://localhost:27017/")

# Access a database
db = client["mydatabase"]

# Access a collection
collection = db["users"]

# Insert a document
collection.insert_one({"name": "Alice", "email": "[email protected]"})
Using Node.js (with Mongoose):
javascript
Copy code
const mongoose = require('mongoose');

mongoose.connect('mongodb://localhost:27017/mydatabase', {
useNewUrlParser: true,
useUnifiedTopology: true
});

const db = mongoose.connection;
db.once('open', () => {
console.log("Connected to MongoDB successfully");
});

3. Connecting to MongoDB Atlas (Cloud-Based)

MongoDB Atlas is a cloud-hosted version of MongoDB, offering automatic scaling, backups, and
security features. To connect to a MongoDB Atlas cluster, the following steps are typically followed:

1. Create an account at https://www.mongodb.com/cloud/atlas

2. Create a cluster and select the desired cloud provider and region.
3. Whitelist your IP address for access control.
4. Create a database user with a username and password.

Dept. of CS&E, MIT Mysore 2024-2025 7

Introduction To MongoDB
5. Copy the connection URI provided by Atlas and replace <password> and <dbname> with
actual values.

Example in Python:
python
Copy code
from pymongo import MongoClient

uri = "mongodb+srv://user123:[email protected]/mydatabase?retryWrites=true&w=majority"
client = MongoClient(uri)
db = client["mydatabase"]

4. Security and Best Practices

 Authentication: Always enable user authentication, especially for cloud databases.

 Encryption: Use SSL/TLS for secure communication, especially over the internet.
 Environment Variables: Store sensitive credentials in environment variables instead of
hardcoding them in the source code.
 Firewall Configuration: When using Atlas, only whitelisted IP addresses can access the
cluster, adding an additional layer of security.

5. Verifying the Connection

After establishing a connection, it is important to verify that the application is successfully
connected:

Python Example:
python
Copy code
print(client.list_database_names())
Node.js Example:
javascript
Copy code
db.listCollections().toArray((err, collections) => {
console.log(collections);
});

Dept. of CS&E, MIT Mysore 2024-2025 8

Introduction To MongoDB

Chapter 4
MongoDB CRUD Operations
In MongoDB, CRUD stands for Create, Read, Update, and Delete, which are the fundamental
operations performed on data in a database. Among these, the Insert (Create) and Find (Read)
operations are the most basic and frequently used in applications that interact with MongoDB.

MongoDB uses a document-oriented model, where data is stored in flexible, JSON-like documents
inside collections. These operations are performed using built-in methods provided by MongoDB
drivers or the MongoDB shell.

1. Insert Operation (Create)

The Insert operation is used to add new documents to a collection in the database. MongoDB
provides different methods to insert one or multiple documents:

a. insertOne()
This method inserts a single document into a collection.

Syntax:
javascript
Copy code

Dept. of CS&E, MIT Mysore 2024-2025 9

Introduction To MongoDB
db.collection.insertOne(document)
Example:
javascript
Copy code
db.students.insertOne({
name: "John Doe",
age: 22,
course: "Computer Science"
})
This command inserts one document with the fields name, age, and course into the students collection. If
the collection does not exist, MongoDB will create it automatically.

b. insertMany()
This method inserts multiple documents at once.

Example:
javascript
Copy code
db.students.insertMany([
{ name: "Alice", age: 21, course: "Electronics" },
{ name: "Bob", age: 23, course: "Mechanical" }
])
This adds two new documents to the students collection. Using insertMany() is efficient for bulk insert
operations.

2. Find Operation (Read)

The Find operation is used to retrieve documents from a collection. MongoDB provides powerful
query capabilities through the find() method.

a. find()
This method retrieves documents that match the specified query criteria.

Syntax:
javascript
Copy code
db.collection.find(query)
Example 1: Find All Documents
javascript
Copy code
db.students.find()
This returns all documents from the students collection.

Example 2: Find Documents with Condition

javascript
Copy code
db.students.find({ age: 22 })
This retrieves all documents where the age is 22.

b. findOne()
This method returns the first document that matches the query condition.

Dept. of CS&E, MIT Mysore 2024-2025 10

Introduction To MongoDB
Example:
javascript
Copy code
db.students.findOne({ name: "John Doe" })
Returns the first document where name equals "John Doe".

3. Using Projection in Find Operation

Projection is used to control which fields are returned in the result.

Example:
javascript
Copy code
db.students.find({ age: 22 }, { name: 1, _id: 0 })
This returns only the name field (excluding _id) for all students aged 22.

4. Practical Example (Using Python with PyMongo)

Insert Example:
python
Copy code
from pymongo import MongoClient

client = MongoClient("mongodb://localhost:27017/")
db = client["university"]
collection = db["students"]

collection.insert_one({"name": "John", "age": 20, "course": "IT"})

Find Example:
python
Copy code
students = collection.find({"course": "IT"})
for student in students:
print(student)

Chapter 5
MongoDB CRUD Operations
MongoDB provides comprehensive support for CRUD operations: Create, Read, Update, and
Delete. After inserting and retrieving data using insert and find, developers often need to replace
existing documents or delete them entirely. MongoDB offers various methods for these tasks,
allowing for powerful and flexible data management.

1. Replace Operation (Update using replaceOne)

The replaceOne() method is used to completely replace a single document in a collection that
matches a given filter. This operation is useful when the entire content of a document needs to be
updated rather than modifying only specific fields.

Dept. of CS&E, MIT Mysore 2024-2025 11

Introduction To MongoDB
Syntax:
javascript
Copy code
db.collection.replaceOne(filter, replacement)

 filter:
The condition used to match the document to replace.
 replacement: The new document that will replace the existing one.

Example:
javascript
Copy code
db.students.replaceOne(
{ name: "John Doe" },
{ name: "John Doe", age: 23, course: "Data Science" }
)
In this example, MongoDB searches the students collection for a document where name is "John Doe"
and replaces it entirely with a new document containing updated age and course values. If the matched
document had other fields, they are lost unless included in the replacement.

2. Delete Operations (deleteOne and deleteMany)

The delete operations are used to remove documents from a collection based on specific filter
criteria. MongoDB supports two main deletion methods:

a. deleteOne()
This method deletes the first document that matches the given condition.

Syntax:
javascript
Copy code
db.collection.deleteOne(filter)
Example:
javascript
Copy code
db.students.deleteOne({ name: "Alice" })
This command deletes the first document in the students collection where the name field is "Alice".

b. deleteMany()
This method deletes all documents that match the specified filter.

Syntax:
javascript
Copy code
db.collection.deleteMany(filter)
Example:
javascript
Copy code
db.students.deleteMany({ course: "Mechanical" })
This deletes all documents where the course is "Mechanical" from the students collection.

Dept. of CS&E, MIT Mysore 2024-2025 12

Introduction To MongoDB
3. Using Python (with PyMongo) for Replace and Delete
Replace Example:
python
Copy code
from pymongo import MongoClient

client = MongoClient("mongodb://localhost:27017/")
db = client["university"]
collection = db["students"]

collection.replace_one(
{"name": "John Doe"},
{"name": "John Doe", "age": 24, "course": "Artificial Intelligence"}
)
Delete Example:
python
Copy code
# Delete a single document
collection.delete_one({"name": "Alice"})

# Delete multiple documents

collection.delete_many({"course": "Mechanical"})

4. Important Considerations

 Backup Before Replacement or Deletion: Since both replaceOne() and deleteMany() can result
in permanent data loss, it is advisable to back up data before executing these operations.
 Use with Caution: Especially deleteMany(), as it can affect a large number of documents.
 Atomicity: These operations are atomic at the document level, meaning each replacement or
deletion happens in isolation.

Chapter 6
MongoDB CRUD Operations
In MongoDB, after performing read operations using methods like find() or findOne(), it is often
necessary to modify the query results to suit the requirements of the application or user. MongoDB
provides several features to modify, filter, limit, sort, and project data during retrieval. These
modifications do not change the data in the database; instead, they shape the output returned by the
query.

Dept. of CS&E, MIT Mysore 2024-2025 13

Introduction To MongoDB
1. Projection
Projection in MongoDB is used to specify or restrict the fields that should be returned in the result
set. By default, MongoDB returns all fields of a document unless specified otherwise.

Syntax:
javascript
Copy code
db.collection.find(query, projection)

 1 includes a field.
 0 excludes a field.

Example:
javascript
Copy code
db.students.find({ course: "IT" }, { name: 1, _id: 0 })
This returns only the name field (excluding _id) of students enrolled in the IT course.

2. Sorting Query Results

MongoDB allows sorting the query results using the sort() method. It can sort in ascending or
descending order based on one or more fields.

Syntax:
javascript
Copy code
db.collection.find().sort({ field: 1 }) // Ascending
db.collection.find().sort({ field: -1 }) // Descending
Example:
javascript
Copy code
db.students.find().sort({ age: -1 })
This query returns all student documents sorted in descending order of their age.

3. Limiting the Number of Results

To restrict the number of documents returned by a query, MongoDB uses the limit() method.

Syntax:
javascript
Copy code
db.collection.find().limit(n)
Example:
javascript
Copy code
db.students.find().limit(5)
This returns the first 5 documents from the students collection.

Dept. of CS&E, MIT Mysore 2024-2025 14

Introduction To MongoDB
4. Skipping Documents
The skip() method is used to skip over a specified number of documents in the result set. This is
especially useful for pagination.

Syntax:
javascript
Copy code
db.collection.find().skip(n)
Example:
javascript
Copy code
db.students.find().skip(5).limit(5)
This skips the first 5 documents and returns the next 5 documents.

5. Combining Methods
All the above methods can be combined for advanced querying and result formatting.

Example:
javascript
Copy code
db.students.find(
{ course: "Computer Science" },
{ name: 1, age: 1, _id: 0 }
).sort({ age: 1 }).skip(2).limit(3)
This query:

 Filters students in the Computer Science course,

 Projects only the name and age fields,
 Sorts the results by age in ascending order,
 Skips the first 2 documents,
 Limits the output to 3 documents.

6. Using Python (with PyMongo)

Projection Example:
python
Copy code
students = db.students.find({ "course": "IT" }, { "name": 1, "_id": 0 })
for student in students:
print(student)
Sorting Example:
python
Copy code
students = db.students.find().sort("age", -1)
Limiting and Skipping:
python
Copy code
students = db.students.find().skip(5).limit(10)

Dept. of CS&E, MIT Mysore 2024-2025 15

Introduction To MongoDB

Fig 2. MongoDB CRUD Operations

Chapter 7
MongoDB CRUD Operations: Insert and Find Documents

Dept. of CS&E, MIT Mysore 2024-2025 16

Introduction To MongoDB
CRUD stands for Create, Read, Update, and Delete – the basic operations in any database system. In
MongoDB, these operations are performed on documents stored in collections. This section focuses
on Insert and Find operations using both the MongoDB Shell and Python (via PyMongo).

1. Inserting Documents

To add new documents to a collection, MongoDB provides the insertOne() and insertMany()
methods.

Syntax:

db.collection.insertOne(document)

db.collection.insertMany([document1, document2, ...])

Example:

db.students.insertOne({

name: "Student A",

age: 21,

course: "CSE"

})

This command inserts a new student document into the students collection.

To insert multiple documents:

db.students.insertMany([

{ name: "John", age: 22, course: "ECE" },

{ name: "Priya", age: 23, course: "IT" }

])

2. Finding Documents

To retrieve documents from a collection, the find() or findOne() method is used.

Syntax:

db.collection.find(query)

db.collection.findOne(query)

 find() returns a cursor to all documents that match the query.

 findOne() returns the first matching document.

Examples:

Dept. of CS&E, MIT Mysore 2024-2025 17

Introduction To MongoDB
db.students.find()

Returns all documents in the students collection.

db.students.find({ course: "IT" })

Returns the first document where the name is "John".

3. Using Python (with PyMongo)

Inserting Documents:

db.students.insert_one({

"name": "Student A",

"age": 21,

"course": "CSE"

})

To insert multiple documents:

db.students.insert_many([

{ "name": "John", "age": 22, "course": "ECE" },

{ "name": "Priya", "age": 23, "course": "IT" }

])

Finding Documents:

# Find all students

students = db.students.find()

for student in students:

print(student)

# Find students by course

students = db.students.find({ "course": "IT" })

# Find one student by name

student = db.students.find_one({ "name": "John" })

print(student)

Chapter 8
MongoDB CRUD Operations: Replace and Delete Documents
Dept. of CS&E, MIT Mysore 2024-2025 18
Introduction To MongoDB
MongoDB supports replacing and deleting documents as part of its core CRUD operations. These
operations are useful for updating an entire document or removing one or more documents that
match specific criteria.

1. Replacing Documents

The replaceOne() method is used to replace a single document that matches a specified filter with a
completely new document. It does not perform a partial update; the existing document is fully
replaced.

Syntax:

db.collection.replaceOne(filter, replacement)

Example:

db.students.replaceOne(

{ name: "John" },

{ name: "John", age: 24, course: "AI" }

This command finds the first document where name is "John" and replaces the entire document with
the new one provided.

2. Deleting Documents

MongoDB provides two methods to delete documents from a collection: deleteOne() and
deleteMany().

 deleteOne() deletes the first document that matches the filter.

 deleteMany() deletes all documents that match the filter.

Syntax:

db.collection.deleteOne(filter)

db.collection.deleteMany(filter)

Examples:

db.students.deleteOne({ name: "Priya" })

This deletes the first document where the name is "Priya".

db.students.deleteMany({ course: "ECE" })

This deletes all students enrolled in the ECE course.

Dept. of CS&E, MIT Mysore 2024-2025 19

Introduction To MongoDB
3. Using Python (with PyMongo)

Replacing a Document:

db.students.replace_one(

{ "name": "John" },

{ "name": "John", "age": 24, "course": "AI" }

Deleting a Document:

db.students.delete_one({ "name": "Priya" })

Deleting Multiple Documents:

db.students.delete_many({ "course": "ECE" })

Chapter 9
MongoDB CRUD Operations: Modifying Query Results
Dept. of CS&E, MIT Mysore 2024-2025 20
Introduction To MongoDB
After retrieving data using the find() or findOne() methods, MongoDB allows the results to be
refined using various modifiers. These operations are useful for filtering fields, sorting output,
paginating results, and shaping the final result set. It’s important to note that these modifications do
not alter the actual documents in the database — they only affect the result of the query.

1. Projection

Projection is used to include or exclude specific fields from the documents in the query result.

Syntax:

db.collection.find(query, projection)

 Use 1 to include a field.

 Use 0 to exclude a field.

Example:

db.students.find({ course: "IT" }, { name: 1, _id: 0 })

This returns only the name field (excluding _id) of students enrolled in the IT course.

2. Sorting Query Results

Sorting allows results to be ordered based on one or more fields.

Syntax:

db.collection.find().sort({ field: 1 }) // Ascending

db.collection.find().sort({ field: -1 }) // Descending

Example:

db.students.find().sort({ age: -1 })

Returns all student documents sorted in descending order of their age.

3. Limiting the Number of Results

The limit() method is used to restrict the number of documents returned.

Syntax:

db.collection.find().limit(n)

Example:

db.students.find().limit(5)

Returns the first 5 documents from the students collection.

4. Skipping Documents

Dept. of CS&E, MIT Mysore 2024-2025 21

Introduction To MongoDB
The skip() method is used to skip a specified number of documents, often used in pagination.

Syntax:

db.collection.find().skip(n)

Example:

db.students.find().skip(5).limit(5)

Skips the first 5 documents and returns the next 5 documents.

5. Combining Methods

All of the above methods can be combined for advanced querying and formatting of results.

Example:

db.students.find(

{ course: "Computer Science" },

{ name: 1, age: 1, _id: 0 }

).sort({ age: 1 }).skip(2).limit(3)

This query:

 Filters students enrolled in the Computer Science course,

 Skips the first 2 documents,

 Limits the output to 3 documents.

6. Using Python (with PyMongo)

Projection:

students = db.students.find({ "course": "IT" }, { "name": 1, "_id": 0 })

for student in students:

print(student)

Sorting:

students = db.students.find().sort("age", -1)

Limiting and Skipping:

students = db.students.find().skip(5).limit(10)

Chapter 10
MongoDB Aggregation
Dept. of CS&E, MIT Mysore 2024-2025 22
Introduction To MongoDB
Aggregation in MongoDB is the process of transforming and combining data from multiple
documents into a summarized result. MongoDB’s Aggregation Framework is analogous to SQL’s
GROUP BY and supports advanced operations using a pipeline-based approach.

1. Aggregation Pipeline
The aggregation pipeline is a series of stages. Each stage takes input documents, processes them, and
passes the result to the next stage.

db.collection.aggregate([
{ stage1 },
{ stage2 },
...
])

2. Common Aggregation Stages

$match – Filters documents, similar to find() queries.
$group – Groups documents by a specified identifier and performs aggregations like sum, avg.
$project – Reshapes documents and includes or excludes fields.
$sort – Sorts documents by a field.
$limit – Limits the number of documents.
$skip – Skips a specified number of documents.
$unwind – Deconstructs an array field to output a document per element.
$lookup – Joins documents from another collection (like a SQL join).

3. Example: Group and Calculate Average

db.students.aggregate([
{ $match: { course: "IT" } },
{ $group: { _id: "$course", avgAge: { $avg: "$age" } } }
])

4. Example: Join with Another Collection

db.orders.aggregate([
{
$lookup: {
from: "customers",
localField: "customerId",
foreignField: "_id",
as: "customerDetails"
}
}
])

Dept. of CS&E, MIT Mysore 2024-2025 23

Introduction To MongoDB
5. Using Aggregation in Python
pipeline = [
{"$match": {"course": "IT"}},
{"$group": {"_id": "$course", "avgAge": {"$avg": "$age"}}}
]
result = db.students.aggregate(pipeline)
for r in result:
print(r)

6. Use Cases
- Generating reports and summaries
- Analyzing sales or student performance
- Performing real-time analytics

Fig 3. MongoDB Aggregation

Dept. of CS&E, MIT Mysore 2024-2025 24

Introduction To MongoDB
Chapter 11
MongoDB Indexes

Indexes in MongoDB enhance query performance by allowing fast lookups. Without indexes,
MongoDB must scan each document in a collection (a full collection scan).

1. Types of Indexes
Single Field – Index on one field.
Compound – Index on multiple fields.
Multikey – Index on arrays.
Text – Supports full-text search.
Hashed – Used for sharding.
TTL – Automatically deletes documents after a period.

2. Creating Indexes
db.students.createIndex({ name: 1 }) // Ascending
db.students.createIndex({ age: -1 }) // Descending

3. Unique and Sparse Indexes

db.students.createIndex({ email: 1 }, { unique: true })
db.students.createIndex({ phone: 1 }, { sparse: true })

4. TTL Index
db.logs.createIndex({ createdAt: 1 }, { expireAfterSeconds: 3600 })

5. Viewing and Deleting Indexes

db.students.getIndexes()
db.students.dropIndex("name_1")

6. Index Use in Queries

db.students.find({ name: "Alice" }).explain("executionStats")

7. Python Example
collection.create_index([("name", 1)])
collection.drop_index("name_1")

8. Best Practices
- Create indexes for fields used in queries, sorting, or filtering.
- Avoid too many indexes—they can slow down writes.

Dept. of CS&E, MIT Mysore 2024-2025 25

Introduction To MongoDB
Chapter 12

MongoDB Atlas Search

MongoDB Atlas Search provides advanced full-text search capabilities using Lucene, directly
integrated into MongoDB Atlas.

1. Features of Atlas Search

- Integrated full-text indexing.
- Built on Apache Lucene.
- Supports relevance scoring, autocomplete, wildcard, and highlighting.

2. Creating a Search Index

- Navigate to Collections > Search Indexes in the Atlas UI.
- Create an index on a collection.
- Choose fields and set mappings (dynamic or static).

3. Basic $search Query

db.students.aggregate([
{
$search: {
index: "default",
text: {
query: "John",
path: "name"
}
}
}
])

4. Autocomplete Example
db.products.aggregate([
{
$search: {
autocomplete: {
query: "lap",
path: "productName"
}
}
}
])

Dept. of CS&E, MIT Mysore 2024-2025 26

Introduction To MongoDB
5. Compound Search Example
db.blogs.aggregate([
{
$search: {
compound: {
must: [
{ text: { query: "MongoDB", path: "title" } }
],
mustNot: [
{ text: { query: "deprecated", path: "tags" } }
]
}
}
}
])

6. Highlighting Matches
db.articles.aggregate([
{
$search: {
index: "default",
text: {
query: "cloud",
path: "content"
}
}
},
{
$project: {
title: 1,
content: 1,
highlights: { $meta: "searchHighlights" }
}
}
])

7. Search Metadata
db.students.aggregate([
{
$searchMeta: {
text: {
query: "AI",
path: "course"
}

Dept. of CS&E, MIT Mysore 2024-2025 27

Introduction To MongoDB
}
}
])

8. Best Practices
- Use dynamic mappings for quick setup.
- Fine-tune scoring and filters for performance.
- Combine $search with $project, $sort, and $limit for better UX.

CONCLUSION

Dept. of CS&E, MIT Mysore 2024-2025 28

Introduction To MongoDB
The MongoDB internship has been an enriching experience that provided comprehensive insights
into the fundamentals and advanced capabilities of MongoDB, a leading NoSQL database.
Throughout the internship, I gained hands-on experience in implementing CRUD operations,
designing efficient document models, and using Python (via PyMongo) for real-world applications. I
also explored powerful features such as indexing, aggregation pipelines, and full-text search with
MongoDB Atlas.

This internship not only strengthened my understanding of how modern databases operate but also
enhanced my skills in managing and querying unstructured data effectively. By working with real-
world use cases and examples, I developed practical knowledge that is crucial for building scalable
and high-performance web applications. Overall, the internship has significantly boosted my
confidence in using MongoDB as a robust backend solution and has equipped me with essential
database skills for my future career in software development.

Dept. of CS&E, MIT Mysore 2024-2025 29