No-SQL Unit 2: Complete Concepts Guide

1. INTRODUCTION TO DOCUMENT DATABASESCopy Anchor Link

What are Document Databases?Copy Anchor Link

Document databases are a major category of NoSQL databases that store data as flexible, self-describing documents instead of strict rows and columns. Each document contains field-and-value pairs, and the values may include:

• Strings
• Numbers
• Dates
• Arrays
• Embedded documents
• Other supported data types

Real-World Entities as DocumentsCopy Anchor Link

Many real-world entities can be represented as structured documents. For example, a student record may include:

• Personal details
• Address
• Course details
• Marks
• Skills

Instead of splitting all of this data into separate tables, a document database can store much of it together in one document.

Common Applications Using Document DatabasesCopy Anchor Link

• E-commerce platforms
• Learning management systems
• Mobile apps
• Content management systems
• Healthcare records
• IoT systems
• User profile management

2. MONGODB OVERVIEWCopy Anchor Link

What is MongoDB?Copy Anchor Link

MongoDB is one of the most widely used document database systems. It stores records as BSON documents, which are binary representations of JSON-like documents.

MongoDB Organization StructureCopy Anchor Link

Database → Collections → Documents

Why Use MongoDB?Copy Anchor Link

• Flexible document model
• Developer-friendly syntax (JSON-like documents)
• Powerful query language
• Secondary indexes
• Aggregation framework
• Rich tools ecosystem
• Distributed features (replication and sharding)

3. CORE DOCUMENT DATABASE FEATURESCopy Anchor Link

4. DOCUMENT DATABASE VS RELATIONAL DATABASECopy Anchor Link

5. MONGODB ADVANTAGESCopy Anchor Link

6. ENVIRONMENT SETUPCopy Anchor Link

Installation OptionsCopy Anchor Link

General Local Installation StepsCopy Anchor Link

1. Visit the official MongoDB Community Server download/installation documentation
2. Select the correct operating system (Windows, Ubuntu, macOS, or other supported platform)
3. Download and install MongoDB Community Server using installer or package manager
4. Install MongoDB Shell if not included
5. Start the MongoDB server service (typically named mongod)
6. Open terminal/command prompt and run mongosh to connect
7. Verify connection with commands like show dbs and db.version()

Verification Commands:

show dbs
db.version()
db.stats()

Connection MethodsCopy Anchor Link

Important: Use mongodb+srv:// for SRV connection strings (Atlas clusters). Use mongodb:// for standard connection strings (local servers or explicitly listed hosts).

7. MONGODB SHELL (MONGOSH)Copy Anchor Link

What is MongoDB Shell?Copy Anchor Link

MongoDB Shell (mongosh) is an interactive command-line interface for MongoDB. It is useful for:

• Learning commands
• Testing queries
• Managing databases
• Running administrative operations

Essential mongosh CommandsCopy Anchor Link

Common Beginner Shell SessionCopy Anchor Link

// 1. Start shell
mongosh

// 2. View databases
show dbs

// 3. Switch to a database
use collegeDB

// 4. Insert a sample document
db.students.insertOne({ name: "Sneha", department: "AIML", semester: 5 })

// 5. View collections
show collections

// 6. Read documents
db.students.find()

// 7. Count documents
db.students.countDocuments()

8. CRUD OPERATIONSCopy Anchor Link

Preparing a Sample DatabaseCopy Anchor Link

use collegeDB

db.students.insertMany([
  {
    name: "Asha",
    department: "CSE",
    semester: 5,
    city: "Mysuru",
    marks: { dbms: 86, python: 92 },
    skills: ["Python", "MongoDB"]
  },
  {
    name: "Ravi",
    department: "ISE",
    semester: 5,
    city: "Bengaluru",
    marks: { dbms: 78, python: 81 },
    skills: ["Java", "Testing"]
  },
  {
    name: "Meena",
    department: "CSE",
    semester: 3,
    city: "Hubballi",
    marks: { dbms: 91, python: 88 },
    skills: ["Python", "Data Analysis"]
  }
])

8.1 CREATE OperationsCopy Anchor Link

Create operations add new documents to a collection.

Syntax Examples:

// Insert one document
db.students.insertOne({
  name: "Kiran",
  department: "ECE",
  semester: 5,
  city: "Dharwad",
  marks: { dbms: 74, python: 69 },
  skills: ["C", "Electronics"]
})

// Insert multiple documents
db.students.insertMany([
  { name: "John", department: "CSE", semester: 3 },
  { name: "Jane", department: "ISE", semester: 5 }
])

8.2 READ OperationsCopy Anchor Link

Read operations retrieve documents from a collection.

Syntax Examples:

// Read all documents
db.students.find()

// Display in readable format
db.students.find().pretty()

// Find CSE students from semester 5
db.students.find({ department: "CSE", semester: 5 })

// Find students with DBMS marks > 80
db.students.find({ "marks.dbms": { $gt: 80 } })

// Projection: show only name and department
db.students.find({}, { name: 1, department: 1, _id: 0 })

8.3 UPDATE OperationsCopy Anchor Link

Update operations modify existing documents.

Syntax Examples:

// Update one document
db.students.updateOne(
  { name: "Ravi" },
  { $set: { city: "Mangaluru" } }
)

// Update many documents
db.students.updateMany(
  { department: "CSE" },
  { $set: { mentor: "Dr. Rao" } }
)

// Add a new skill to one student's skills array
db.students.updateOne(
  { name: "Asha" },
  { $push: { skills: "Cloud" } }
)

// Increment semester for all students
db.students.updateMany(
  {},
  { $inc: { semester: 1 } }
)

8.4 DELETE OperationsCopy Anchor Link

Delete operations remove documents from a collection.

Syntax Examples:

// Delete one matching document
db.students.deleteOne({ name: "Kiran" })

// Delete all students from a city
db.students.deleteMany({ city: "Hubballi" })

// Count remaining documents
db.students.countDocuments()

Important: Use delete operations carefully - removed documents may not be recoverable unless backups are available.

9. DATA MODELLING PRINCIPLESCopy Anchor Link

What is Data Modelling?Copy Anchor Link

Data modelling means deciding how data will be organized inside the database. In MongoDB, good data modelling starts with access patterns - the designer should first ask:

• What data will the application read together?
• What data will be updated frequently?
• Which queries must be fast?

Key Data Modelling PrinciplesCopy Anchor Link

Embedding vs ReferencingCopy Anchor Link

EmbeddingCopy Anchor Link

Related data is stored inside the same document.

Use when:

• Related data is read together
• Data has a bounded size
• Data doesn’t change independently

Advantages:

• Fast single-document reads
• Natural document structure
• Atomic updates

Precautions:

• Avoid very large documents
• Avoid unbounded arrays

Example:

{
  name: "Asha",
  department: "CSE",
  address: {
    city: "Mysuru",
    pin: 570001
  }
}

ReferencingCopy Anchor Link

Related data is stored in separate collections and linked using IDs.

Use when:

• Related data is large
• Data is shared between documents
• Data is frequently updated independently

Advantages:

• Reduces duplication
• Separates large datasets
• More flexible for independent updates

Precautions:

• May require multiple queries
• May need aggregation lookup

Example:

{
  name: "Asha",
  departmentId: ObjectId("...")
}

Design RuleCopy Anchor Link

Data that is accessed together should generally be stored together. However, if related data grows without limit or is updated independently, referencing may be a better design.

10. INDEXING STRATEGIESCopy Anchor Link

What are Indexes?Copy Anchor Link

Indexes are special data structures that make queries faster. Without an index, MongoDB may need to scan every document in a collection to find matches. With a suitable index, MongoDB can locate matching documents more efficiently.

Types of IndexesCopy Anchor Link

Creating and Viewing IndexesCopy Anchor Link

// Create a single-field index
db.students.createIndex({ department: 1 })

// Create a compound index
db.students.createIndex({ department: 1, semester: 1 })

// Create an index on an array field
db.students.createIndex({ skills: 1 })

// View existing indexes
db.students.getIndexes()

// Drop an index by name
db.students.dropIndex("department_1")

Indexing Strategy RulesCopy Anchor Link

1. Create indexes for fields used frequently in filters, sorting, and joins/lookups
2. Use compound indexes when queries commonly use multiple fields together
3. Choose compound index field order carefully - the first field and prefix fields are important for query support
4. Avoid creating too many indexes (each index uses storage and slows write operations)
5. Use explain() to check whether a query is using an index
6. Remove unused indexes after analyzing workload and performance needs

Analyzing Query Execution:

db.students.find({ department: "CSE" }).explain("executionStats")

Best PracticeCopy Anchor Link

Indexes improve read performance but add overhead to insert, update, and delete operations because MongoDB must maintain the index structures. Create indexes based on real query requirements.

11. AGGREGATION FRAMEWORKCopy Anchor Link

What is the Aggregation Framework?Copy Anchor Link

The aggregation framework processes documents through a pipeline of stages. Each stage receives input documents, performs an operation, and passes the result to the next stage. Aggregation is used for:

• Reporting
• Analytics
• Grouping
• Filtering
• Sorting
• Reshaping documents

Common Aggregation StagesCopy Anchor Link

Example 1: Department-wise Average MarksCopy Anchor Link

db.students.aggregate([
  {
    $group: {
      _id: "$department",
      averageDBMS: { $avg: "$marks.dbms" },
      totalStudents: { $sum: 1 }
    }
  },
  {
    $sort: { averageDBMS: -1 }
  }
])

Example 2: Filter, Project, and SortCopy Anchor Link

db.students.aggregate([
  { $match: { semester: 5 } },
  {
    $project: {
      _id: 0,
      name: 1,
      department: 1,
      totalMarks: { $add: ["$marks.dbms", "$marks.python"] }
    }
  },
  { $sort: { totalMarks: -1 } }
])

Explanation: This pipeline first selects fifth-semester students, then creates a new computed field called totalMarks, and finally sorts the output in descending order of total marks.

Example 3: Working with Array DataCopy Anchor Link

db.students.aggregate([
  { $unwind: "$skills" },
  {
    $group: {
      _id: "$skills",
      numberOfStudents: { $sum: 1 }
    }
  },
  { $sort: { numberOfStudents: -1 } }
])

Explanation: $unwind separates each skill in the skills array into an individual pipeline item. Then $group counts how many students have each skill.

Important NoteCopy Anchor Link

Aggregation pipelines usually do not modify the original documents. However, special stages such as $merge or $out can write results to a collection, so use them carefully.

12. PERFORMANCE ANALYSISCopy Anchor Link

Performance FactorsCopy Anchor Link

13. KEY TERMS GLOSSARYCopy Anchor Link

14. CHAPTER SUMMARYCopy Anchor Link

• Document databases store records as flexible documents instead of fixed rows and columns
• MongoDB organizes data into databases, collections, and BSON documents
• MongoDB supports CRUD operations through methods such as insertOne(), find(), updateOne(), and deleteOne()
• mongosh is an important tool for interactive MongoDB practice
• Good MongoDB data modelling depends on application access patterns
• Embedding is useful when related data is read together and has a bounded size; referencing is useful when related data is large or independent
• Indexes improve query performance but add storage and write overhead
• Aggregation pipelines process documents through stages such as $match, $group, $sort, and $project