MongoDB

❖ Welcome to Param Classes!

Every application needs a proper system to store and manage information. For example, a school management application stores student details, teacher information, courses, fees and attendance records. An e-commerce application stores products, customers, orders and payments.

MongoDB organizes this information using a simple but powerful structure called Database, Collections and Documents.

Understanding MongoDB architecture is important before learning CRUD operations, queries, aggregation and database management.

In this tutorial, we will understand MongoDB architecture step by step with practical examples, document structures and commands.

✦ 1. What Is MongoDB Architecture?

MongoDB architecture explains how information is organized and stored inside a MongoDB database.

MongoDB follows a document-oriented data model. Instead of storing information in traditional relational tables, it stores records as documents. These documents are grouped into collections, and collections are stored inside databases.

The basic MongoDB structure is:

MongoDB Server
      |
      |-- Database
              |
              |-- Collection
                      |
                      |-- Document 1
                      |-- Document 2
                      |-- Document 3

Let's understand each component in detail.

✦ 2. What Is a Database in MongoDB?

A database is a container used to organize and store collections.

For example, imagine you are developing a school management application. You can create a database named:

school_management

Inside this database, you can create collections for different types of information:

• students

• teachers

• courses

• fees

• attendance

Each collection stores related documents.

A MongoDB server can contain multiple databases for different applications or purposes.

❖ Example: Creating a Database

Open MongoDB Shell (mongosh) and execute:

use school_management

This switches to the school_management database. MongoDB creates the database when data is first stored in it.

To check the current database:

db

To list available databases:

show dbs

Remember: Selecting a database with use does not necessarily create it immediately. A database generally becomes visible after data is stored in it.

✦ 3. What Is a Collection in MongoDB?

A collection is a group of related documents inside a database.

You can compare a MongoDB collection with a table in an SQL database, although they do not work exactly the same way.

For example, inside the school_management database, you can create these collections:

students
teachers
courses
fees

The students collection stores student documents, while the teachers collection stores teacher documents.

❖ Example: Creating a Collection

Use the following command:

db.createCollection("students")

This creates a collection named students in the current database.

To display collections:

show collections

You can also create a collection automatically by inserting its first document.

✦ 4. What Is a Document in MongoDB?

A document is an individual record stored inside a collection.

MongoDB stores documents in BSON format, which is a binary representation of JSON-like data.

For example, a student document may look like this:

{
  "_id": 101,
  "name": "Rahul Kumar",
  "age": 22,
  "course": "BCA",
  "city": "Raipur"
}

Let's understand its fields:

• _id – Unique identifier for the document.

• name – Student's name.

• age – Student's age.

• course – Student's course.

• city – Student's city.

Every MongoDB document must have a unique _id within its collection. If you do not provide one, MongoDB normally generates an ObjectId automatically.

❖ Example: Insert a Document

db.students.insertOne({
  name: "Rahul Kumar",
  age: 22,
  course: "BCA",
  city: "Raipur"
})

This command inserts one student document into the students collection.

To view the inserted document:

db.students.find()

✦ 5. Understanding the Relationship Between Database, Collection and Document

Let's understand this structure with a real-world example.

Imagine a school management application.

Database: school_management

Collections:

• students

• teachers

• courses

Documents inside students collection:

{
  "name": "Rahul",
  "course": "BCA",
  "city": "Raipur"
}

{
  "name": "Amit",
  "course": "MCA",
  "city": "Bilaspur"
}

Both documents belong to the same students collection, which belongs to the school_management database.

<escape>Think of it like this:</escape>

• Database = School record system.

• Collection = Student register.

• Document = One student's record.

This simple comparison makes MongoDB architecture easier to understand.

✦ 6. Can MongoDB Documents Have Different Fields?

Yes! One important feature of MongoDB is its flexible document structure.

For example, the first student document may contain:

{
  "name": "Rahul",
  "course": "BCA"
}

The second document may contain:

{
  "name": "Priya",
  "course": "MCA",
  "city": "Raipur",
  "skills": ["Python", "Java", "MongoDB"]
}

Both documents can exist inside the same collection.

This flexibility is useful when different records require different information.

However, flexible documents do not mean that you should design data without rules. Proper validation and consistent field naming are important for reliable applications.

✦ 7. How Does MongoDB Store Nested Documents?

MongoDB allows you to store objects inside other documents. These are called embedded or nested documents.

For example:

{
  "name": "Rahul Kumar",
  "course": "BCA",
  "address": {
    "city": "Raipur",
    "state": "Chhattisgarh",
    "pincode": 492001
  }
}

Here, address is an embedded document containing city, state and pincode.

You can also store arrays:

{
  "name": "Rahul",
  "skills": [
    "HTML",
    "CSS",
    "JavaScript",
    "MongoDB"
  ]
}

Nested documents and arrays help represent related information in a natural structure.

✦ 8. How to View MongoDB Database Structure

MongoDB Shell provides useful commands to explore databases and collections.

Command	Purpose
show dbs	Display databases
use school_management	Switch database
show collections	Display collections
db	Display current database
db.students.find()	Display student documents
db.students.countDocuments()	Count student documents

Try these commands in mongosh to understand how MongoDB organizes information.

✦ 9. MongoDB Architecture vs SQL Database Structure

MongoDB and SQL databases organize information differently.

MongoDB	SQL Database
Database	Database
Collection	Table (similar concept)
Document	Row (similar concept)
Field	Column (similar concept)
BSON document	Structured table record

These are conceptual comparisons, not exact equivalents. MongoDB documents can contain nested objects and arrays, while relational databases commonly represent related information using separate tables and relationships.

✦ 10. Why Is Understanding MongoDB Architecture Important?

Understanding the database, collection and document structure helps you:

1. Organize application information properly.

2. Create collections based on application requirements.

3. Insert and retrieve documents.

4. Design nested data structures.

5. Write better MongoDB queries.

6. Understand indexing and aggregation.

7. Build scalable database-driven applications.

Before moving to advanced MongoDB topics, practice creating databases, collections and documents using MongoDB Shell or MongoDB Compass.

❖ Conclusion

MongoDB architecture is based on three important components: Database, Collections and Documents.

A database contains collections, collections contain documents, and documents store information in flexible BSON-based structures.

Once you understand these concepts, learning MongoDB CRUD operations, query operators, indexing and aggregation becomes much easier.

At Param Classes, we believe practical learning is the best way to understand programming and database technologies. Practice these commands, create your own database and gradually build real-world applications.

Learn Today, Grow Tomorrow!