Module 5 : NoSQL Databases:MongoDB

Apply the CRUD operations to insert, update, and delete documents in a MongoDB
MongoDB, a popular NoSQL database, supports CRUD operations: Create, Read, Update, and Delete.
These operations are fundamental for interacting with data in any database management system. Here's
a brief explanation of each CRUD operation in the context of MongoDB:
The name Mongo comes from “humongous”—with performance and easy data access as core design
goals.

1. Create (Insert):
 In MongoDB, the insert() method is used to create new documents (records) in a
collection (similar to a table in relational databases).
 Documents in MongoDB are represented in BSON (Binary JSON) format, which is a
binary-encoded serialization of JSON-like documents.
 Example:
javascript
[Link]({ "name": "John Doe", "age": 25, "grade": "A" });
2. Read (Query):
 MongoDB provides various methods to read/query documents from a collection.
 The find() method is commonly used to retrieve documents that match certain criteria.
 Example:
javascript
[Link]({ "age": { $gte: 20 } });
This query retrieves all documents from the students collection where the age field is greater than or
equal to 20.
3. Update:
 MongoDB offers the update() method to modify existing documents in a collection.
 The $set operator is frequently used to update specific fields within a document.
 Example:
javascript
[Link]( { "name": "John Doe" }, { $set: { "grade": "B" } } );
This updates the grade field of the document where the name is "John Doe" to "B".
4. Delete:
 MongoDB provides the remove() method to delete documents from a collection.
 It can delete documents based on specific criteria or remove all documents from a
collection.
 Example:
javascript
[Link]({ "age": { $lt: 18 } });
This removes all documents from the students collection where the age field is less than 18.
These CRUD operations form the core functionalities needed for managing data in MongoDB. They
allow developers to create, retrieve, update, and delete documents efficiently, making MongoDB a
versatile choice for various types of applications.
Apply the CRUD operations to insert, update, and delete documents in a MongoDB collection.

CRUD operations stand for Create, Read, Update, and Delete, and they are fundamental operations for
interacting with data in any database system, including MongoDB. Here's how you can perform
CRUD operations in MongoDB:

Create (Insert): To insert documents into a MongoDB collection, you can use the insertOne() or
insertMany() methods.
javascript
// Insert a single document
[Link]({
"name": "John Doe",
"age": 30,
"email": "john@[Link]"
});

// Insert multiple documents

[Link]([
{
"name": "Jane Smith",
"age": 25,
"email": "jane@[Link]"
},
{
"name": "Bob Johnson",
"age": 35,
"email": "bob@[Link]"
}
]);
Read: To read documents from a MongoDB collection, you can use the find() method.
javascript
// Find all documents in the collection
[Link]();

// Find documents that match a specific query

[Link]({ "age": { $gt: 30 } }); // Find documents where age is greater than 30
Update: To update documents in a MongoDB collection, you can use the updateOne() or
updateMany() methods.

javascript
// Update a single document
[Link](
{ "name": "John Doe" }, // Filter
{ $set: { "age": 31 } } // Update operation
);

// Update multiple documents

[Link](
{ "age": { $lt: 30 } }, // Filter
{ $inc: { "age": 1 } } // Update operation (increment age by 1)
);
Delete: To delete documents from a MongoDB collection, you can use the deleteOne() or
deleteMany() methods.
javascript
// Delete a single document
[Link]({ "name": "John Doe" });

// Delete multiple documents

[Link]({ "age": { $gte: 40 } }); // Delete documents where age is greater than or
equal to 40
Remember to replace "collection" with the actual name of your collection in MongoDB. These
operations should be executed within the MongoDB shell or through a MongoDB driver in your
programming language of choice (e.g., [Link], Python).

MongoDB offers a rich set of features beyond the basic CRUD operations. Let's explore each of
them briefly:
1. CRUD Operations: Covered in the previous response, CRUD operations stand for Create,
Read, Update, and Delete, which are fundamental to interacting with data in MongoDB.
2. Nesting: MongoDB allows for nested documents within documents, enabling complex data
structures to be represented. This feature is useful for modeling relationships between entities
without the need for joins as in relational databases.
3. Indexing: MongoDB supports various types of indexes, including single field, compound,
multi-key, text, and geospatial indexes. Indexing improves query performance by allowing the
database to quickly locate documents based on indexed fields.
4. Aggregation: MongoDB provides an aggregation framework that allows for data processing
and transformation operations such as grouping, filtering, and computing aggregations (e.g.,
sum, average) across multiple documents in a collection.
5. Map-Reduce: Although MongoDB's aggregation framework is preferred for most data
processing tasks, it also supports map-reduce operations for complex data transformations and
analysis. Map-reduce can be used for tasks that cannot be easily expressed using the
aggregation framework.
6. Replica Set: A replica set in MongoDB is a group of MongoDB instances that maintain the
same data set. Replica sets provide high availability and data redundancy by automatically
electing a primary node for writes and replicating data to secondary nodes.
7. Sharding: Sharding is a method for distributing data across multiple MongoDB instances to
horizontally scale out databases. MongoDB sharding partitions data into chunks and distributes
these chunks across shards, enabling linear horizontal scaling as data grows.
8. Geospatial Indexing: MongoDB supports geospatial indexing and queries, allowing for the
storage and retrieval of location-based data. Geospatial indexes enable efficient spatial queries
such as finding points within a specified radius or finding objects within a geographical area.
9. GridFS: MongoDB's GridFS is a specification for storing and retrieving large files, such as
images, videos, and documents, in MongoDB databases. GridFS stores files as separate
documents, enabling efficient streaming and retrieval of large files.
These features collectively make MongoDB a powerful and flexible NoSQL database solution suitable
for a wide range of use cases, from small-scale applications to large-scale enterprise systems.

Aggregate Function:
By doing this, will get redundancy and increases data availability with multiple copies of data on
different database servers.
So, it will increase the performance of reading scaling. The set of servers that maintain the same copy
of data is known as replica servers or MongoDB instances

Replication and Sharding

Replication
Replication can be simply understood as the duplication of the data-set whereas sharding is
partitioning the data-set into discrete [Link] sharding, we divided your collection into different parts.

Replicating your database means you make imagers of your data-set. In terms of functionality
delivered.

Replication is the method of duplication of data across multiple servers. For example, we have an
application and it reads and writes data to a database and says this server A has a name and balance
which will be copied/replicate to two other servers in two different locations.

By doing this, will get redundancy and increases data availability with multiple copies of data on
different database servers.
So, it will increase the performance of reading scaling. The set of servers that maintain the same copy
of data is known as replica servers or MongoDB instances

Sharding
Sharding is a method for allocating data across multiple machines. MongoDB used sharding to help
deployment with very big data sets and large throughput the operation. By sharding, you combine
more devices to carry data extension and the needs of read and write operations.

Why Sharding?
Database systems having big data sets or high throughput requests can doubt the ability of a single
server.
For example, High query flows can drain the CPU limit of the server.
The working set sizes are larger than the system’s RAM to stress the I/O capacity of the disk drive.
How does Sharding work?
Sharding determines the problem with horizontal scaling breaking the system dataset and store over
multiple servers, adding new servers to increase the volume as needed.

Now, instead of one signal as primary, we have multiple servers called Shard. We have different
routing servers that will route data to the shard servers. For example: Let say we have Data 1, Data 2,
and Data 3 this will be going to the routing server which will route the data (i.e, Different Data will go
to a particular Shard ) Each Shard holds some pieces of data. Here the configuration server will hold
the metadata and it will configure the routing server to integrate the particular data to a shard however
configure server is the MongoDB instance if it goes down then the entire server will go down, So it
again has Replica Configure database

1. Geospatial Indexing:
 Purpose: Geospatial indexing allows MongoDB to efficiently store, manage, and query
geospatial data, such as points, lines, and polygons, based on their geographical
coordinates.
 Implementation: MongoDB supports two types of geospatial indexes:
 2d Index: Ideal for flat surfaces like maps. It indexes data points on a two-
dimensional plane using longitude and latitude coordinates.
 2dsphere Index: Suitable for the Earth's surface, this index supports data points
represented in GeoJSON format, allowing for more complex geometries like
polygons and spheres.
 Querying: MongoDB provides various geospatial queries such as:
 $near: Finds objects near a specified point.
 $geoWithin: Finds objects within a specified area.
 $geoIntersects: Finds objects intersecting a specified geometry.
 Use Cases: Geospatial indexing is valuable in applications involving location-based
services, mapping, geotagging, and spatial analytics.
2. GridFS:
 Purpose: GridFS is a specification used by MongoDB for storing and retrieving large
files exceeding the BSON document size limit of 16MB.
 Architecture: GridFS stores large files by breaking them into smaller chunks (typically
255KB in size) and storing each chunk as a separate document in MongoDB.
 Collections: GridFS uses two MongoDB collections:
 [Link]: Stores metadata about the files, such as filename, content type, and other
attributes.
 [Link]: Stores the binary data of the files in chunks.
 Advantages: GridFS enables efficient storage, retrieval, and streaming of large files,
making it suitable for multimedia applications, document storage, and content
management systems.
 APIs: MongoDB provides APIs and drivers for working with GridFS, abstracting the
complexities of managing large files across multiple documents.
In summary, Geospatial Indexing and GridFS are powerful features of MongoDB that extend its
capabilities to handle spatial data and large files efficiently. These features are essential for building
applications that involve geospatial analysis, location-based services, multimedia content storage, and
document management.

 Implement indexing on a specific field in a MongoDB collection to optimize query

performance.
Implementing indexing on specific fields in a MongoDB collection can significantly improve query
performance, especially when dealing with large datasets. Here's how you can create an index on a
specific field in a MongoDB collection:
Connect to MongoDB: First, connect to your MongoDB server using the MongoDB shell or a
MongoDB driver in your programming language.

Choose the Field to Index: Identify the field that you want to index. Generally, fields used in query
conditions, sorting, or aggregations are good candidates for indexing.

Create Index: You can create an index using the createIndex() method. You can specify the field to
index and additional options.

javascript
// Syntax: [Link]({ <field>: <type> })
[Link]({ "field_to_index": 1 });
In the above command:

collection: The name of your MongoDB collection.

"field_to_index": The field you want to index.
1: Specifies that the index should be in ascending order. You can use -1 for descending order.
For example, if you want to create an index on the "name" field of a collection called "users", you
would run:

javascript
[Link]({ "name": 1 });
Verify Index Creation: You can verify that the index has been created using the getIndexes() method.

javascript
[Link]();
This command will return a list of indexes for the specified collection, including the newly created
index.

Query Optimization: After creating the index, MongoDB will use it to optimize queries involving the
indexed field. Queries that filter, sort, or perform aggregations using the indexed field will benefit
from improved performance.
It's essential to consider the trade-offs associated with indexing, such as increased storage space and
the overhead of maintaining indexes during write operations. Therefore, index selection should be
based on the specific requirements and usage patterns of your application.

•Create a basic Map-Reduce function for a given MongoDB dataset.

Map-Reduce is a programming model used for processing and generating large datasets that reside in a
MongoDB collection. It consists of two primary functions: the map function, which processes each
document and emits key-value pairs, and the reduce function, which processes the output of the map
function and performs aggregation.

Here's a basic example of how to create a Map-Reduce function for a given MongoDB dataset:

Suppose we have a collection named sales with documents representing sales transactions, each
containing fields like item, quantity, and price.
javascript

// Map function

var mapFunction = function() {

emit([Link], [Link] * [Link]); // Emit key-value pairs (item, total price)

};

// Reduce function

var reduceFunction = function(key, values) {

return [Link](values); // Summing up the total price for each item

};

// Perform Map-Reduce operation

[Link](

mapFunction,

reduceFunction,

out: "total_sales" // Store the results in a new collection named total_sales

);

In the above code:

Map Function: The mapFunction processes each document in the sales collection and emits key-value
pairs where the key is the item and the value is the quantity multiplied by the price.

Reduce Function: The reduceFunction takes the output of the map function, which groups sales by
item, and sums up the total price for each item.

Perform Map-Reduce Operation: The mapReduce() method is called on the sales collection, passing
the map and reduce functions as arguments. We also specify an output collection named total_sales
where the results will be stored.

After running the Map-Reduce operation, you can query the total_sales collection to retrieve the
aggregated results. For example:

javascript

db.total_sales.find();
This will return documents containing the total sales for each item, as calculated by the Map-Reduce
function.

Map-Reduce is a powerful tool for processing large datasets in MongoDB, but it's important to note
that it may not be the most efficient solution for all use cases, especially with the introduction of the
aggregation framework in MongoDB, which provides more flexible and efficient ways to perform data
processing and analysis.

 Incorporate GridFS into the design of a media storage system in MongoDB. Create a
schema that allows efficient storage and retrieval of large files such as images or videos
using GridFS.

GridFS is a specification used in MongoDB for storing and retrieving large files, such as images,
videos, and audio files, which exceed the BSON-document size limit of 16 MB. It achieves this by
breaking the files into smaller chunks and storing them as separate documents.

To design a media storage system using GridFS in MongoDB, you don't necessarily define a schema in
the traditional sense. Instead, you use GridFS APIs to interact with the database. However, you might
still have metadata associated with each file, which can be stored alongside the file in MongoDB
documents.

Here's how you can incorporate GridFS into the design of a media storage system:

Install the MongoDB [Link] Driver: If you're using [Link], you can install the MongoDB [Link]
driver using npm:
bash
npm install mongodb
Connect to MongoDB: Connect to your MongoDB server using the MongoDB [Link] driver.

Store Files Using GridFS: Use GridFS to store large files in MongoDB.

javascript
const { MongoClient, GridFSBucket } = require('mongodb');
const fs = require('fs');

// MongoDB connection URL

const uri = 'mongodb://localhost:27017';
const client = new MongoClient(uri);

async function main() {

try {
await [Link]();

// Database and GridFSBucket

const database = [Link]('media');
 const bucket = new GridFSBucket(database);

// Path to the file you want to store

const filePath = 'path_to_your_file/[Link]';

// Open a readable stream from the file

const fileStream = [Link](filePath);

// Create an upload stream to store the file in MongoDB

const uploadStream = [Link]('[Link]');

// Pipe the file stream into the upload stream

[Link](uploadStream);

// Wait for the upload to finish

[Link]('finish', () => {
[Link]('File uploaded successfully');
[Link]();
});
} catch (error) {
[Link]('Error:', error);
}
}

main();
Retrieve Files Using GridFS: Use GridFS to retrieve stored files from MongoDB.
javascript
async function getFile(filename) {
try {
await [Link]();

const database = [Link]('media');

const bucket = new GridFSBucket(database);

// Create a download stream for the file

const downloadStream = [Link](filename);

// Create a write stream to save the file to disk

const fileWriteStream = [Link](`downloaded_${filename}`);

// Pipe the download stream into the file write stream

[Link](fileWriteStream);

// Wait for the download to finish

[Link]('end', () => {
[Link]('File downloaded successfully');
 [Link]();
});
} catch (error) {
[Link]('Error:', error);
}
}

getFile('[Link]');
In the above examples, we've demonstrated how to store and retrieve files using GridFS in MongoDB
with the [Link] driver. You can customize these functions based on your specific requirements, such
as adding metadata to files or implementing error handling.
.
Understand the role of indexing in improving query performance in MongoDB
Indexing plays a crucial role in improving query performance in MongoDB. MongoDB uses indexes to
quickly locate and retrieve documents from collections based on the criteria specified in queries.
Here's how indexing helps improve query performance:
1. Faster Query Execution: Indexes help MongoDB efficiently locate documents by creating a
sorted data structure that allows for faster lookup based on indexed fields. When a query
includes fields covered by indexes, MongoDB can use these indexes to quickly find matching
documents without scanning the entire collection.
2. Reduced Scanning and Document Examination: Without indexes, MongoDB must perform
a collection scan, where it examines every document in the collection to find matches for a
query. This can be resource-intensive and slow, especially for large collections. Indexes reduce
the need for collection scans by providing a more direct path to matching documents.
3. Optimized Sorting and Aggregation: Indexes can also improve the performance of sorting
and aggregation operations. When sorting or aggregating results based on indexed fields,
MongoDB can leverage indexes to efficiently order and group documents, reducing the
processing time required for these operations.
4. Covered Queries: MongoDB can perform covered queries when all the fields required by a
query are included in an index. In such cases, MongoDB can fulfill the query by examining
only the index entries, without needing to access the actual documents in the collection. This
can lead to significant performance gains, especially for read-heavy workloads.
5. Index Intersection: MongoDB can use multiple indexes to satisfy a single query by
performing index intersection. This allows MongoDB to combine the results of multiple index
scans to find matching documents efficiently.
6. Index Types: MongoDB supports various types of indexes, including single-field indexes,
compound indexes (indexes on multiple fields), multi-key indexes (indexes on array fields),
geospatial indexes, and text indexes. Choosing the appropriate index type based on the query
patterns and data characteristics can further enhance query performance.
In summary, indexing in MongoDB is essential for optimizing query performance by reducing query
execution time, minimizing the need for collection scans, and facilitating efficient sorting and
aggregation operations. Properly designed indexes can significantly improve the overall
responsiveness and scalability of MongoDB databases, especially in applications with high read and
query loads.
Aggregation in MongoDB refers to the process of performing operations on collections to process and
analyze data and return computed results. MongoDB provides a powerful aggregation framework that
enables users to perform complex data manipulations, transformations, and computations on
documents stored in collections. Here's how aggregation works and its significance in MongoDB:

Describe how Aggregation and its significance in MongoDB.

1. Pipeline-based Approach: MongoDB's aggregation framework operates using a pipeline-
based approach. A pipeline consists of a sequence of stages, where each stage performs a
specific operation on the documents that pass through it. The output of one stage serves as the
input to the next stage, allowing for a series of data processing steps.
2. Wide Range of Operations: MongoDB's aggregation framework offers a wide range of
operations and expressions that can be used within pipeline stages. These operations include
filtering, grouping, sorting, projecting, joining, and performing mathematical computations and
transformations on data.
3. Flexibility and Expressiveness: The aggregation framework provides a flexible and
expressive way to perform data analysis and aggregation directly within the database server.
Users can express complex data processing logic using a combination of pipeline stages and
operators, making it possible to implement various data aggregation and reporting
requirements.
4. Efficient Processing: MongoDB's aggregation framework is designed for efficient processing
of large datasets. It leverages internal optimizations, such as parallelism, index usage, and
memory management, to execute aggregation queries efficiently even on large collections.
5. Integration with Indexes: MongoDB's aggregation framework can take advantage of indexes
to improve query performance. By properly indexing fields used in aggregation operations,
MongoDB can efficiently retrieve and process relevant documents, leading to faster query
execution times.
6. Significance: The aggregation framework is significant in MongoDB because it enables users
to perform sophisticated data analysis and aggregation tasks directly within the database
system. This reduces the need to transfer large volumes of data to client applications for
processing, which can improve overall application performance and scalability.
7. Support for Real-time Analytics: MongoDB's aggregation framework supports real-time
analytics by allowing users to perform near real-time data processing and analysis on live data.
This makes it suitable for building applications that require continuous monitoring, reporting,
and analysis of streaming data.
Overall, MongoDB's aggregation framework is a powerful tool for performing data aggregation,
analysis, and computation within the database system. Its flexibility, efficiency, and integration with
MongoDB's query engine make it an essential feature for building data-intensive applications and
performing complex data analysis tasks.

Analyze the benefits and challenges of using nesting in MongoDB documents

Using nesting in MongoDB documents, often referred to as embedded documents or subdocuments,

offers several benefits and also presents some challenges. Let's explore both aspects:
Benefits:
1. Data Locality: Nesting allows related data to be stored together within a single document. This
can improve data locality and reduce the need for complex joins that are common in relational
databases. Retrieving nested documents can be more efficient compared to performing multiple
queries across different collections.
 2. Performance: Retrieving nested documents typically requires fewer database operations
compared to fetching data from separate collections, which can lead to better performance,
especially for read-heavy workloads.
3. Atomicity: MongoDB provides atomic operations on individual documents. When updates are
made to nested documents within a single operation, MongoDB ensures that these updates are
atomic, meaning they either all succeed or all fail. This helps maintain data consistency and
integrity.
4. Schema Flexibility: MongoDB's schema flexibility allows documents within a collection to
have varying structures. This means that different documents can contain different nested
fields, allowing for dynamic schema design and accommodating evolving application
requirements without requiring schema migrations.
Challenges:
1. Document Size Limitations: MongoDB has a maximum document size limit of 16 MB. If
nested documents become too large, they can potentially exceed this limit, leading to issues
with document storage and retrieval.
2. Data Duplication and Redundancy: Nesting can lead to data duplication and redundancy,
especially if nested documents are shared across multiple parent documents. This can increase
storage requirements and may require additional effort to ensure data consistency and integrity.
3. Limited Querying Flexibility: While nesting can improve query performance for certain use
cases, it can also limit querying flexibility. Nested documents may require traversing multiple
levels of nesting, which can make queries more complex and less intuitive compared to
relational databases.
4. Indexing Challenges: Indexing nested fields can be challenging, especially when dealing with
deeply nested structures. MongoDB supports indexing on nested fields, but indexing decisions
should be carefully considered based on query patterns and performance requirements.
5. Updates and Atomicity: While MongoDB provides atomic operations at the document level,
updates to nested documents can become complex, especially in scenarios where multiple
clients may concurrently update the same parent document with nested fields.
6. Schema Design Complexity: Designing an effective schema with nesting requires careful
consideration of data relationships, access patterns, and performance requirements. Poorly
designed nested schemas can lead to data access inefficiencies and maintenance challenges
over time.
In summary, while nesting in MongoDB documents offers benefits such as improved data locality,
performance, and schema flexibility, it also presents challenges related to document size limitations,
data redundancy, querying flexibility, indexing, updates, and schema design complexity. It's important
for developers to carefully evaluate the trade-offs and design document structures that best fit their
application requirements and use cases.

 Explain Geospatial and GridFS

Geospatial and GridFS are two important features in MongoDB, each serving
distinct purposes:
Geospatial Data:
MongoDB supports geospatial data through geospatial indexes and queries, which allow for the
storage and efficient retrieval of location-based information. Geospatial data typically involves points,
lines, polygons, or multi-dimensional shapes representing real-world geographic features. MongoDB's
geospatial capabilities enable developers to build location-aware applications and perform spatial
queries for tasks such as proximity searches, location-based recommendations, and spatial analytics.
Key Components:
1. Geospatial Indexes: MongoDB supports indexing on geospatial data using 2d indexes (for flat
surfaces like maps) and 2dsphere indexes (for spherical geometries like the Earth's surface).
Indexes help improve query performance when searching for documents based on their
geographic coordinates.
2. Geospatial Queries: MongoDB provides various geospatial query operators such as $near,
$geoWithin, and $geoIntersects to perform spatial queries. These operators enable developers
to search for documents based on their proximity to a specific point, containment within a
specified area, or intersection with a given geometry.
3. Geospatial Data Types: MongoDB supports several geospatial data types, including Point,
LineString, Polygon, MultiPoint, MultiLineString, MultiPolygon, and GeometryCollection.
These data types represent different geometric shapes and can be stored in MongoDB
documents.
4. Geospatial Indexing and Sharding: MongoDB's geospatial indexes can be sharded, allowing
for the distribution of geospatial data across multiple shards for horizontal scalability and
improved performance.
5. Purpose: Geospatial support in MongoDB enables the storage, indexing, and querying of
geographic data.
6. Features: MongoDB supports 2d and 2dsphere indexes for flat and spherical geometries,
respectively. It provides geospatial query operators like $near, $geoWithin, and
$geoIntersects.
7. Data Types: MongoDB supports various geospatial data types including Point, LineString,
Polygon, MultiPoint, MultiLineString, MultiPolygon, and GeometryCollection.
8. Use Cases: Geospatial capabilities are useful for location-based applications, proximity
searches, spatial analytics, and geospatial data visualization.
9. Scalability: Geospatial indexes can be sharded for horizontal scalability and distributed storage
of geospatial data across MongoDB clusters.

GridFS:
GridFS is a specification implemented by MongoDB for storing and retrieving large files, such as
images, videos, audio files, and documents, that exceed the 16 MB document size limit in MongoDB.
GridFS stores files in a MongoDB database in a more efficient manner by breaking them into smaller
chunks, which are then stored as separate documents.
Key Components:

1. File Chunks: GridFS divides large files into smaller chunks, typically 255 KB in size by
default, and stores each chunk as a separate document in two collections: [Link] and
[Link]. This allows MongoDB to handle files of virtually any size by distributing them
across multiple documents.
2. Metadata Storage: Metadata associated with each file, such as filename, content type, file
size, and custom attributes, is stored in the [Link] collection. This metadata can be queried and
indexed like any other MongoDB document fields.
3. Streaming Support: GridFS provides streaming support for reading and writing large files,
enabling developers to efficiently stream data to and from GridFS without loading the entire
file into memory.
4. Replication and Sharding: GridFS data can be replicated and sharded in MongoDB clusters,
allowing for high availability, fault tolerance, and horizontal scalability of file storage.
5. Purpose: GridFS is a specification implemented by MongoDB for storing and retrieving large
files that exceed the 16 MB document size limit.
6. File Storage: GridFS stores files as separate documents in two collections: [Link] for metadata
and [Link] for file chunks.
7. Chunking: Large files are broken into smaller chunks (default size 255 KB) and stored as
binary data in the [Link] collection.
8. Streaming Support: GridFS provides streaming support for reading and writing large files,
allowing efficient data transfer without loading the entire file into memory.
9. Replication and Sharding: GridFS data can be replicated and sharded in MongoDB clusters,
ensuring high availability, fault tolerance, and horizontal scalability of file storage.
10. Use Cases: GridFS is suitable for storing large media files, such as images, videos, audio files,
and documents, in MongoDB databases. It is commonly used in applications with heavy file
storage requirements.

In summary, Geospatial and GridFS are two powerful features in MongoDB that enable developers
to work with geospatial data and store and retrieve large files efficiently. Geospatial support
facilitates the development of location-aware applications, while GridFS allows MongoDB to
handle large files that exceed the document size limit, providing a scalable solution for file storage
and retrieval.