Introduction

MongoDB Compass is a powerful, user-friendly graphical user interface (GUI) for interacting with MongoDB databases. It simplifies database management and provides a visual interface for querying, analyzing, and manipulating data. Compass is designed for developers, database administrators, and anyone who prefers to work with MongoDB visually rather than via the command line or code.

In this module, we will explore how to use MongoDB Compass for various tasks, including:

1. Connecting to a MongoDB Database
2. Viewing and Navigating Collections
3. Querying Data
4. Updating Data
5. Creating and Managing Indexes
6. Visualizing Data

1. Connecting to a MongoDB Database

To start working with MongoDB Compass, you first need to connect to a MongoDB database, either locally or remotely (via MongoDB Atlas or other cloud solutions).

Steps to Connect:

1. Open MongoDB Compass.
2. Enter the connection string:
   • For a local database, the default connection string is mongodb://localhost:27017.
   • For MongoDB Atlas, obtain the connection string from your Atlas dashboard.
3. Click Connect:
   • After entering the connection details, click the Connect button. MongoDB Compass will attempt to connect to the database.
   • Once connected, you will see a list of available databases.

2. Viewing and Navigating Collections

Once connected, you can explore the databases and collections within MongoDB Compass.

Navigating the Database:

1. Select a Database: On the left-hand panel, you will see a list of databases. Click on a database to expand it and view the collections within it.
2. View Collections: Each database consists of multiple collections. You can click on any collection to view its documents.
3. Inspect Documents: MongoDB Compass allows you to view the documents in the collection in a tabular format. Each document will be displayed with a list of fields and their values.

Example:

• If you have a users collection, you can click on it to see documents with fields like name, email, and address.

3. Querying Data

MongoDB Compass provides a visual interface to run queries without needing to write raw MongoDB commands. You can filter and search for documents based on specific field values.

Using the Query Bar:

1. Basic Queries: Use the query bar at the top of the Compass window to filter documents by specific criteria. For example, you can query users based on their name or email: { "name": "John Doe" } This will show all documents where the name field matches "John Doe".
2. Advanced Queries: MongoDB Compass also supports more advanced query options, including operators like $gt (greater than), $lt (less than), $in (matches values in a list), and others.
   • Example: Find users with age greater than 30: { "age": { "$gt": 30 } }
3. Query Filters and Projections:
   • You can also project specific fields to be included in the result. For example, to display only the name and email fields: { }
     • Under Projection, input the fields you want to include: { "name": 1, "email": 1 }
4. Sorting: You can sort the results by any field in ascending or descending order. Just click on the “Sort” option in the filter panel and choose the field and order.

4. Updating Data

MongoDB Compass allows you to update documents directly from the GUI. You can modify fields, add new ones, or even delete fields.

Steps to Update Data:

1. Select a Document: After running a query and displaying the results, select a document from the list to open it in the editor.
2. Modify the Fields: In the editor, you can change the values of fields directly. Add, delete, or modify the values.
3. Save Changes: After making changes, click the Update button to save your modifications.

Example:

• If you want to update the email address of a user, you can click the document, edit the email field, and then click Update.

5. Creating and Managing Indexes

Indexes in MongoDB are essential for optimizing query performance. MongoDB Compass makes it easy to manage indexes by providing a visual interface.

Steps to Create an Index:

1. Go to the Indexes Tab: Inside the collection view, click on the Indexes tab.
2. Create New Index: Click on the Create Index button.
3. Select Fields: You will be prompted to choose one or more fields to index. You can choose fields based on your query patterns.
4. Choose Index Type: You can choose between ascending (1), descending (-1), and other types of indexes.
5. Create Index: Click Create to create the index. MongoDB Compass will automatically build the index in the background.

Example:

• To speed up queries based on the email field, you can create an index on the email field.

6. Visualizing Data

One of the powerful features of MongoDB Compass is its ability to visualize data, making it easier to analyze the structure of your database and documents.

Data Visualizations:

• Schema View: MongoDB Compass automatically analyzes the data in your collections and provides a Schema view, showing the types of fields, their frequency, and other statistical information.
  • You can visualize how many documents contain specific fields and their data types.
• Data Explorer: In the Data Explorer tab, MongoDB Compass will show graphs and charts based on the data in your collection, allowing for easy insights into your dataset.

Conclusion

MongoDB Compass is a powerful tool that simplifies the management and manipulation of MongoDB databases. It allows you to:

• Connect to MongoDB locally or remotely.
• View and navigate collections.
• Query and filter data with ease.
• Update documents directly.
• Create and manage indexes.
• Visualize your data for better insights.

By using MongoDB Compass, you can improve productivity and reduce the need for manually typing MongoDB commands.

Introduction

MongoDB, being a NoSQL database, is quite flexible when it comes to storing data. Unlike traditional relational databases, MongoDB stores data in BSON (Binary JSON) format, which is a rich data format that can accommodate various complex data types. Understanding the various data types in MongoDB is crucial for modeling your data effectively.

In this module, we will cover the following important MongoDB data types:

1. ObjectId
2. Date
3. Embedded Documents
4. Arrays

1. ObjectId

In MongoDB, every document has a unique identifier called _id. By default, MongoDB assigns an ObjectId as the value for the _id field when a new document is created. ObjectId is a 12-byte identifier that guarantees uniqueness across machines and time.

Structure of ObjectId:

• 4 bytes representing the timestamp of creation (in seconds).
• 5 bytes of random value generated once per process.
• 3 bytes of incrementing counter, initialized to a random value.

Syntax:

ObjectId()

Example:

// Inserting a document with ObjectId as default _id
async function insertUser() {
  await client.connect();
  const db = client.db("myDatabase");
  const usersCollection = db.collection("users");

  const result = await usersCollection.insertOne({
    name: "Alice Smith",
    email: "[email protected]"
  });

  console.log(`New user inserted with ID: ${result.insertedId}`);
}

insertUser().catch(console.error).finally(() => client.close());

Explanation:

• If no _id is provided during the insert operation, MongoDB automatically generates a unique ObjectId for the document.

Using ObjectId in Queries:

You can query a document using its _id field.

const user = await usersCollection.findOne({ _id: ObjectId("5f47a3f2e7c8bda5b4ef3029") });

2. Date

MongoDB stores dates in the Date data type, which is an instance of the JavaScript Date object. MongoDB’s Date type stores the date and time in milliseconds since the Unix epoch (January 1, 1970).

Syntax:

new Date() // current date and time

Example:

// Inserting a document with a Date field
async function insertDate() {
  await client.connect();
  const db = client.db("myDatabase");
  const eventsCollection = db.collection("events");

  const result = await eventsCollection.insertOne({
    eventName: "Conference",
    eventDate: new Date("2025-06-15T09:00:00Z") // Date in ISO format
  });

  console.log(`Event inserted with ID: ${result.insertedId}`);
}

insertDate().catch(console.error).finally(() => client.close());

Explanation:

• The new Date() function creates a Date object in MongoDB.
• You can store specific date and time information by passing an ISO string to the Date constructor.

Using Date in Queries:

You can query documents based on Date fields:

const event = await eventsCollection.findOne({ eventDate: { $gt: new Date("2025-01-01") } });

This query will return documents where the eventDate is greater than January 1, 2025.

3. Embedded Documents

MongoDB allows you to store documents within documents, referred to as embedded documents. This feature allows you to represent complex hierarchical data structures.

Example:

// Inserting a user with embedded address document
async function insertUserWithAddress() {
  await client.connect();
  const db = client.db("myDatabase");
  const usersCollection = db.collection("users");

  const result = await usersCollection.insertOne({
    name: "Bob Johnson",
    email: "[email protected]",
    address: {
      street: "123 Main St",
      city: "New York",
      zipCode: "10001"
    }
  });

  console.log(`User with address inserted, ID: ${result.insertedId}`);
}

insertUserWithAddress().catch(console.error).finally(() => client.close());

Explanation:

• In this example, the address field is an embedded document that contains street, city, and zipCode as subfields.
• The embedded document is treated just like any other document and can be queried, updated, and manipulated using MongoDB operations.

Querying Embedded Documents:

To query embedded documents, use dot notation to access the fields inside the embedded document:

const user = await usersCollection.findOne({ "address.city": "New York" });

4. Arrays

MongoDB supports storing arrays as a data type, allowing you to store multiple values in a single field. This is useful for storing lists or sets of values, such as tags, items in an order, or skills for a person.

Example:

// Inserting a user with multiple skills stored as an array
async function insertUserWithSkills() {
  await client.connect();
  const db = client.db("myDatabase");
  const usersCollection = db.collection("users");

  const result = await usersCollection.insertOne({
    name: "Jane Doe",
    skills: ["JavaScript", "Node.js", "MongoDB"]
  });

  console.log(`User with skills inserted, ID: ${result.insertedId}`);
}

insertUserWithSkills().catch(console.error).finally(() => client.close());

Explanation:

• The skills field is an array containing multiple values, representing the skills of a user.
• You can add, remove, and update array elements using MongoDB’s array operators.

Querying Arrays:

You can query documents based on array elements:

const user = await usersCollection.findOne({ skills: "MongoDB" });

This query returns documents where the skills array contains the value "MongoDB".

Conclusion

MongoDB provides a flexible data model through its support for various data types. These types allow you to model data effectively for your applications, whether you’re working with simple or complex structures. Here’s a summary of the data types covered in this module:

• ObjectId: A unique identifier automatically assigned to documents by MongoDB.
• Date: Stores date and time information, which can be used for querying and sorting.
• Embedded Documents: Allows you to nest documents within other documents for hierarchical data modeling.
• Arrays: Allows you to store multiple values in a single field.

These data types give you the power to design your schema efficiently, leveraging the flexibility and scalability MongoDB provides.

Introduction

In this module, we will explore the basic CRUD operations in MongoDB, which are essential for interacting with data stored in a MongoDB database. CRUD stands for Create, Read, Update, and Delete, the four fundamental operations required to manage data. These operations are performed using specific methods in MongoDB, and we’ll cover how to use them for everyday database tasks.

• insertOne: Adds a single document to a collection.
• find: Queries documents from a collection.
• updateOne: Updates a single document in a collection.
• deleteOne: Deletes a single document from a collection.

1. insertOne: Creating a New Document

The insertOne method is used to add a new document to a collection in MongoDB. The document is written in BSON (Binary JSON) format and can contain any number of fields.

Syntax:

db.collection.insertOne(document)

• document: A JavaScript object representing the document to be inserted.

Example:

// Connecting to the MongoDB instance
const { MongoClient } = require('mongodb');
const uri = "mongodb://localhost:27017"; // MongoDB URL
const client = new MongoClient(uri);

// Connecting to the database and inserting a document
async function run() {
  await client.connect();
  const db = client.db("myDatabase");
  const usersCollection = db.collection("users");

  // Inserting a new user document
  const result = await usersCollection.insertOne({
    name: "John Doe",
    age: 28,
    email: "[email protected]"
  });

  console.log(`New user inserted with ID: ${result.insertedId}`);
}

run().catch(console.error).finally(() => client.close());

Explanation:

• In this example, we connect to the myDatabase database and the users collection.
• A new user document is inserted with fields: name, age, and email.
• The insertedId field contains the unique identifier for the newly inserted document.

2. find: Querying Documents

The find method is used to retrieve documents from a collection. It can return all documents or be filtered based on specific conditions.

Syntax:

db.collection.find(query, projection)

• query (Optional): The filter conditions to apply on the documents.
• projection (Optional): Specifies the fields to include or exclude from the returned documents.

Example:

// Finding users with age greater than 25
async function findUsers() {
  await client.connect();
  const db = client.db("myDatabase");
  const usersCollection = db.collection("users");

  const users = await usersCollection.find({ age: { $gt: 25 } }).toArray();
  console.log("Users found: ", users);
}

findUsers().catch(console.error).finally(() => client.close());

Explanation:

• The query { age: { $gt: 25 } } retrieves all documents where the age field is greater than 25.
• The toArray() method is used to return the results as an array of documents.

Projection Example:

If you only want specific fields in the result, use the projection argument:

const users = await usersCollection.find({}, { projection: { name: 1, email: 1 } }).toArray();

This query will only return the name and email fields for all documents in the users collection.

3. updateOne: Updating a Single Document

The updateOne method is used to modify an existing document in a collection. It updates only the first document that matches the query criteria.

Syntax:

db.collection.updateOne(query, update, options)

• query: The filter condition used to find the document to update.
• update: The update operations to perform (e.g., $set, $inc).
• options (Optional): Options to modify the update behavior (e.g., upsert to insert a new document if no match is found).

Example:

// Updating the age of a user by name
async function updateUser() {
  await client.connect();
  const db = client.db("myDatabase");
  const usersCollection = db.collection("users");

  const result = await usersCollection.updateOne(
    { name: "John Doe" }, // Query to find the user
    { $set: { age: 29 } } // Update operation to set new age
  );

  console.log(`${result.matchedCount} document(s) matched, ${result.modifiedCount} document(s) updated.`);
}

updateUser().catch(console.error).finally(() => client.close());

Explanation:

• The query { name: "John Doe" } searches for the user with the name “John Doe”.
• The update operation { $set: { age: 29 } } updates the user’s age to 29.
• The result object contains matchedCount (number of matched documents) and modifiedCount (number of documents actually updated).

4. deleteOne: Deleting a Single Document

The deleteOne method is used to delete a single document that matches the specified query. Like updateOne, it will only delete the first document that matches the query condition.

Syntax:

db.collection.deleteOne(query)

• query: The filter condition used to find the document to delete.

Example:

// Deleting a user by name
async function deleteUser() {
  await client.connect();
  const db = client.db("myDatabase");
  const usersCollection = db.collection("users");

  const result = await usersCollection.deleteOne({ name: "John Doe" });

  console.log(`${result.deletedCount} document(s) deleted.`);
}

deleteUser().catch(console.error).finally(() => client.close());

Explanation:

• The query { name: "John Doe" } identifies the document to be deleted.
• The deletedCount field in the result indicates how many documents were deleted (in this case, it should be 1 if the document exists).

Conclusion

The basic CRUD operations in MongoDB are fundamental for interacting with your data. Here’s a quick summary of what we’ve covered:

• insertOne: Insert a single document into a collection.
• find: Retrieve documents from a collection based on specified query conditions.
• updateOne: Modify a single document that matches the query conditions.
• deleteOne: Delete a single document that matches the query conditions.

These operations form the building blocks for interacting with MongoDB, whether you’re working on a small application or integrating MongoDB into a larger system. Mastering these operations will enable you to efficiently manage and manipulate data in MongoDB.

Introduction

In MongoDB, there are several ways to interact with the database, each suited to different use cases and user preferences. In this module, we will explore the three primary ways to interact with MongoDB:

1. MongoDB Shell
2. MongoDB Compass
3. MongoDB Drivers

Each of these tools provides unique features and benefits, depending on the context and the user’s needs. Understanding these tools will help you make the best decision for interacting with MongoDB in different environments.

1. MongoDB Shell

The MongoDB Shell is an interactive JavaScript shell used for managing and querying MongoDB databases. It’s a command-line interface (CLI) that allows you to interact directly with your MongoDB instance, execute administrative tasks, run queries, and perform database operations.

Key Features of MongoDB Shell:

• Command-line Interface (CLI): MongoDB Shell provides a terminal interface for performing operations on the database.
• Scripting and Automation: You can write JavaScript scripts to automate complex tasks, queries, and administrative functions.
• Direct Interaction: Allows users to execute ad-hoc queries, manage collections, and interact with the MongoDB instance in real-time.
• Access to All MongoDB Features: Through the shell, you have full access to all MongoDB features, including CRUD operations, aggregation, indexing, and administrative tasks.

Basic Operations in MongoDB Shell:

# Start the MongoDB shell
mongo

# Connect to a specific database
use myDatabase

# Insert a document into a collection
db.users.insertOne({ name: "John", age: 30 })

# Find a document
db.users.find({ name: "John" })

# Update a document
db.users.updateOne({ name: "John" }, { $set: { age: 31 } })

# Delete a document
db.users.deleteOne({ name: "John" })

Advantages of MongoDB Shell:

• Flexibility: You can interact directly with the database using MongoDB’s query language.
• Speed: Command-line tools are generally faster for quick, real-time queries and operations.
• Automation: You can write scripts to automate common tasks and integrate them into batch processing jobs.

Disadvantages of MongoDB Shell:

• Steep Learning Curve: Requires knowledge of MongoDB commands and JavaScript to use effectively.
• Not Ideal for Visual Representation: Since it’s a CLI, there are no graphical interfaces to visualize data or schema.

2. MongoDB Compass

MongoDB Compass is the official graphical user interface (GUI) for MongoDB. It provides a rich, user-friendly interface for exploring and managing your MongoDB databases.

Key Features of MongoDB Compass:

• GUI Interface: MongoDB Compass allows you to interact with MongoDB through a visual interface rather than using the command line.
• Data Exploration: You can view collections, documents, and schemas in a visual manner. You can also explore data and index structures without needing to write queries.
• Query Building: MongoDB Compass provides an intuitive query builder where you can create and test MongoDB queries visually.
• Real-time Analytics: Compass provides aggregation pipeline support, allowing you to run real-time analytics on your MongoDB data.
• Schema Visualization: It provides a Schema Explorer to visualize the structure of your documents and spot inconsistencies in data types.
• Data Validation: You can validate documents against JSON Schema to ensure the quality and consistency of your data.

Basic Operations in MongoDB Compass:

• Visualize Schema: Compass automatically generates a visual representation of your document schema.
• Build Queries Visually: You can use the query builder to filter documents without writing complex queries.
• Index Management: You can manage indexes, creating and deleting them, and see their impact on your data performance.

Advantages of MongoDB Compass:

• User-Friendly: Provides an intuitive, visual interface for those who prefer not to use the command line.
• Schema Visualization: Helps visualize the structure of the data, making it easier to understand the schema of your collections.
• Real-Time Analytics: With Compass, you can visualize and analyze your data in real time, which is helpful for reporting and decision-making.

Disadvantages of MongoDB Compass:

• Limited Automation: Unlike the shell, Compass does not support scripting and automation of tasks.
• Heavier Tool: Compass can be resource-intensive, especially when dealing with large datasets, and may not be suitable for all environments.
• Learning Curve for New Users: Although GUI-based, there may still be some learning curve for users unfamiliar with MongoDB.

3. MongoDB Drivers

MongoDB Drivers are software libraries that allow you to connect and interact with MongoDB using different programming languages. These drivers provide a programmatic interface for accessing MongoDB databases, performing CRUD operations, and integrating MongoDB with your application.

MongoDB provides drivers for several programming languages, including:

• Java
• Node.js
• Python
• Go
• C#
• PHP
• Ruby

Key Features of MongoDB Drivers:

• Language-Specific Libraries: Drivers provide bindings to interact with MongoDB using the native syntax and features of a given programming language.
• Asynchronous Support: Many drivers support asynchronous operations, which are particularly useful for web applications that require non-blocking I/O.
• Integration with Applications: Drivers are designed for use within web applications, back-end services, and microservices to integrate MongoDB as a database.
• CRUD Operations: Drivers provide methods to perform standard MongoDB operations, such as inserting, updating, deleting, and querying data.

Basic Operations in MongoDB Driver (Node.js Example):

const { MongoClient } = require('mongodb');

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

// Connect to the database
async function run() {
  await client.connect();
  const database = client.db("myDatabase");
  const users = database.collection("users");

  // Insert a document
  await users.insertOne({ name: "John", age: 30 });

  // Find a document
  const user = await users.findOne({ name: "John" });
  console.log(user);
}

run().catch(console.dir);

Advantages of MongoDB Drivers:

• Integration with Apps: The drivers are essential for integrating MongoDB with your application code, making them indispensable for full-stack development.
• Asynchronous Support: Modern drivers support asynchronous programming, which is great for high-performance applications.
• Language-Specific Features: Since the drivers are tailored to specific languages, you can take full advantage of language features, such as promises, async/await, and error handling.

Disadvantages of MongoDB Drivers:

• Requires Programming Knowledge: Drivers require you to write code to interact with the database, which may not be ideal for users unfamiliar with programming.
• Potential Complexity: Depending on the complexity of your application, using the driver may require additional setup and configuration.

Comparison of MongoDB Shell, MongoDB Compass, and MongoDB Drivers

Conclusion

• MongoDB Shell is ideal for developers who prefer working with the command line, writing scripts, and running quick queries.
• MongoDB Compass is best suited for users who prefer a graphical interface and need to visualize their data, perform analysis, or explore their schema without writing queries.
• MongoDB Drivers are essential for developers building applications, as they allow for seamless integration with MongoDB and provide programmatic access to all database features.

Each of these tools serves a specific purpose, and selecting the right one depends on your use case and preference. As part of the MERN stack, MongoDB drivers are integral to connecting your back-end code (Node.js, for example) to MongoDB, while MongoDB Compass is great for visualizing and managing your data during development.

Introduction

In this module, we will explore the core components of MongoDB’s architecture. MongoDB is a NoSQL database that is designed to store, process, and retrieve data efficiently. It uses a document-oriented storage model, which differs significantly from the table-based approach in relational databases.

By the end of this module, you will understand:

• The structure and organization of Collections and Documents.
• The BSON format used to store data in MongoDB.
• How MongoDB organizes and accesses data efficiently.

1. Collections in MongoDB

In MongoDB, a Collection is the equivalent of a table in a relational database. Collections are used to store documents and are part of a Database.

• A Database in MongoDB can contain multiple collections, but collections within a database do not have a strict schema.
• Collections are designed to be flexible, allowing you to store different types of documents within the same collection.

Key Characteristics of Collections:

• Collections do not enforce data integrity (no foreign keys, joins, etc.).
• Collections are schema-less, meaning documents can have different fields, types, and structures.
• Collections can store data for various types of applications, such as e-commerce, social media, or logging systems.

Example:

Consider an e-commerce platform storing products and orders.

{
  "products": [
    { "name": "Laptop", "price": 999, "category": "Electronics" },
    { "name": "Shoes", "price": 49, "category": "Footwear" }
  ],
  "orders": [
    { "order_id": "123", "customer_id": "456", "status": "Shipped" },
    { "order_id": "124", "customer_id": "457", "status": "Pending" }
  ]
}

In the above example, products and orders could each be represented as a separate collection in MongoDB.

2. Documents in MongoDB

In MongoDB, Documents are the fundamental unit of data storage. They are analogous to rows in relational databases. However, unlike rows in relational tables, MongoDB documents are flexible and can have different fields and structures within the same collection.

Key Characteristics of Documents:

• Each document is represented as a JSON-like structure, typically using BSON format (Binary JSON).
• Each document has a unique identifier called _id, which is automatically generated by MongoDB unless you specify one.
• Documents in a collection can have different fields, meaning they don’t have to follow a rigid schema.

Structure of a MongoDB Document:

A MongoDB document is a set of key-value pairs (fields and values). The key represents the field name, and the value represents the field’s value. Here’s an example of a document in a products collection:

{
  "_id": "12345",
  "name": "Laptop",
  "price": 999,
  "category": "Electronics",
  "in_stock": true,
  "reviews": [
    { "user": "John", "rating": 5, "comment": "Excellent product!" },
    { "user": "Sara", "rating": 4, "comment": "Good value for money." }
  ]
}

• _id: Unique identifier for the document. By default, MongoDB generates an ObjectId if not provided.
• name, price, category: Fields containing data about the product.
• reviews: An array containing embedded documents that represent customer reviews.

3. BSON: Binary JSON

MongoDB stores its data in a binary-encoded format called BSON (Binary JSON). BSON is similar to JSON but has some differences and optimizations for performance and storage efficiency.

Key Characteristics of BSON:

• Binary format: BSON is a binary representation of JSON-like documents. While JSON is a text-based format, BSON is optimized for speed, space, and portability.
• Supports additional data types: BSON supports more data types than JSON, such as Date, Binary data, ObjectId, and others.
• Size: BSON is generally more compact than JSON and is specifically designed for efficient storage and retrieval.

Common BSON Data Types:

• String: UTF-8 string (e.g., "name": "Laptop")
• Integer: 32-bit integer (e.g., "age": 30)
• Long: 64-bit integer (e.g., "timestamp": 1622125323000)
• Double: 64-bit floating point number (e.g., "price": 999.99)
• Boolean: True/False value (e.g., "in_stock": true)
• Date: Date and time (e.g., "created_at": ISODate("2023-07-01T10:00:00Z"))
• ObjectId: Unique identifier used by MongoDB (e.g., "id": ObjectId("507f191e810c19729de860ea"))
• Array: Arrays of values (e.g., "reviews": [ ... ])
• Embedded Document: A document inside another document (e.g., "reviews": { "user": "John", "rating": 5 })

Example of BSON Document:

BSON documents appear similar to JSON, but under the hood, they are binary-encoded for performance.

{
  "_id": ObjectId("507f191e810c19729de860ea"),
  "name": "Laptop",
  "price": 999.99,
  "category": "Electronics",
  "in_stock": true,
  "created_at": ISODate("2023-07-01T10:00:00Z")
}

This document would be stored in BSON format on disk, providing a more efficient structure than plain JSON.

4. How Data is Stored in MongoDB

• Storage Engine: MongoDB uses a storage engine to manage how data is stored and retrieved. The default storage engine is WiredTiger, which is designed for high performance and concurrent operations.
• Indexes: MongoDB allows you to create indexes on specific fields to improve query performance. By default, MongoDB creates an index on the _id field.

How MongoDB Uses Collections and Documents:

1. When you insert data, MongoDB stores the document in a collection.
2. The data is stored in BSON format, making it easier to read and write.
3. MongoDB organizes the documents in collections, making it simple to query, update, and delete documents.

Conclusion

In this module, we’ve covered the core architectural components of MongoDB:

• Collections: The container for storing documents.
• Documents: The data units that are stored in collections.
• BSON: The binary format used to store documents efficiently in MongoDB.

With this foundational understanding, you are ready to dive deeper into how to interact with MongoDB to perform CRUD operations, implement queries, and work with more advanced features.