DEV Community: NAHULESWARAN S 24CB031

CRUD Operations in MongoDB — Student Management System

NAHULESWARAN S 24CB031 — Sat, 01 Nov 2025 12:24:08 +0000

🎯 Objective

To gain hands-on experience performing CRUD (Create, Read, Update, Delete) operations in MongoDB Atlas using a simple college student schema.

MongoDB is a NoSQL document database that stores data in a flexible, JSON-like format — making it ideal for dynamic and structured data such as student records.

🧱 Schema Design

We’ll use a collection called students.
Each student document follows this structure:

{
"student_id": "S001",
"name": "Santhosh",
"age": 20,
"department": "CSBS",
"year": 2,
"cgpa": 9
}

⚙️Step 1: Create (Insert)

Insert at least 5 student records into the students collection.

MongoDB Query:
db.students.insertMany

{
"student_id": "S001",
"name": "Santhosh",
"age": 20,
"department": "CSBS",
"year": 2,
"cgpa": 9
},
{
"student_id": "S002",
"name": "Priya",
"age": 19,
"department": "CSE",
"year": 1,
"cgpa": 8.7
},
{
"student_id": "S003",
"name": "Karthik",
"age": 21,
"department": "IT",
"year": 3,
"cgpa": 7.4
},
{
"student_id": "S004",
"name": "Meena",
"age": 22,
"department": "ECE",
"year": 4,
"cgpa": 8.1
},
{
"student_id": "S005",
"name": "Arun",
"age": 20,
"department": "CSBS",
"year": 2,
"cgpa": 9.2
}

✅ Result in Atlas:
Inserted 5 documents successfully.

🔍 Step 2: Read (Query)

a. Display all student records
db.students.find();

b. Find all students with CGPA > 8
db.students.find({ cgpa: { $gt: 8 } });

c. Find students belonging to the Computer Science department
db.students.find({ department: { $in: ["CSE", "CSBS"] } });

✅ Tip:
Use the MongoDB Atlas “Filter” option to test these queries easily.

✏️ Step 3: Update

a. Update the CGPA of a specific student
Example: Update Santhosh’s CGPA to 9.5
db.students.updateOne(
{ student_id: "S001" },
{ $set: { cgpa: 9.5 } }
);

Modified 1 document.

b. Increase the year of study for all 3rd-year students by 1
db.students.updateMany(
{ year: 3 },
{ $inc: { year: 1 } }
);

✅ Output:
Shows how many documents were modified.

Step 4: Delete

a. Delete one student record by student_id
Example: Delete student S003
db.students.deleteOne({ student_id: "S003" });

b. Delete all students having CGPA < 7.5
db.students.deleteMany({ cgpa: { $lt: 7.5 } });

✅ Output:
Displays number of deleted documents.

📤Step 5: Export the Collection

After performing all CRUD operations, you can export your collection from MongoDB Atlas:

🪶 Steps:

Go to your cluster → Collections → Select students.
Click Export Collection.
Choose JSON or CSV format.
Download your file.
📸 Deliverables

✅ MongoDB Queries (as shown above)
✅ Screenshots of query results (from Atlas)
✅ Exported students.json or students.csv file

🌟** Conclusion**
This hands-on lab demonstrates how easily MongoDB handles CRUD operations using a flexible schema.
The students collection can be expanded further to include additional attributes like address, email, or course list — giving you real-world database experience for college or project work.

Database Normalization: From 1NF to 3NF

NAHULESWARAN S 24CB031 — Fri, 10 Oct 2025 05:07:34 +0000

n this blog, we’ll understand how to normalize a database table step-by-step from 1NF → 2NF → 3NF using clear SQL examples and outputs.

We’ll start from a single unnormalized table containing student, course, and instructor data, and then progressively decompose it to remove redundancy and anomalies.

Identify Anomalies
Insertion Anomaly: We can’t add a new student without assigning a course.
Update Anomaly: If Dr. Kumar changes his phone number, multiple rows must be updated.
Deletion Anomaly: If Arjun drops all courses, his details will be deleted too.

First Normal Form (1NF)

Create a table

Insert data

Output

Second Normal Form (2NF)

Remove partial dependencies.
Create tables separately

Insert values into the respected table

Output

Third Normal Form (3NF)

Remove transitive dependencies — InstructorPhone depends on Instructor, not directly on Course.

In this case, the InstructorPhone depends on Instructor, not directly on Course.
So we already separated Instructors, which makes this 3NF compliant.

Tables in 3NF:

1.Students(StudentID, StudentName)
2.Instructors(Instructor, InstructorPhone)
3.Courses(CourseID, CourseName, Instructor)
4,StudentCourses(StudentID, CourseID)

Query Using JOINs

This structure ensures:
No redundant instructor or course info
Easy updates and clean data relationships
Faster JOIN queries in real databases

We achieved a clean, normalized schema that eliminates anomalies and improves consistency.

Cursor +Trigger

NAHULESWARAN S 24CB031 — Fri, 10 Oct 2025 04:45:58 +0000

In SQL, sometimes you need more than just basic queries.
What if you want to process each row individually?
Or automatically record every change happening in your table?

That’s where Cursors and Triggers come in.

Let’s walk through both with clear examples, outputs, and real-world use cases!

A Cursor in SQL works like a pointer that allows you to process rows one by one from a query result.
It’s useful when you need conditional logic or procedural control inside your SQL block.

A Trigger is like a background assistant that automatically executes when a specific event occurs. For example, when someone inserts, updates, or deletes data.

Cursor Example
Create a table

Insert the values

Output

Cursor Code (Employees with Salary > 50,000)

Trigger Example (AFTER INSERT Trigger)

Create table Student_Audit

Create AFTER INSERT Trigger

Insert Data into table and get output

SUMMARY
1.Cursors allow row-by-row processing of query results.
2.Triggers automate actions on data changes (here, logging inserts).
Both Cursors and Triggers bring life to SQL databases.
:Use Cursors when you need fine-grained control.
:Use Triggers to automate repetitive monitoring or logging.

ACID Properties in DBMS

NAHULESWARAN S 24CB031 — Fri, 10 Oct 2025 04:39:10 +0000

Databases power almost every application we use daily—from banking systems to e-commerce platforms. To ensure data remains reliable, databases follow the ACID principles: Atomicity, Consistency, Isolation, and Durability.

Setup the Schema
We’ll create a Loans table that stores customer loan detail

Enter the values

Result

ATOMICITY
All operations in a transaction must succeed or none should.

Update and roll back

Consistency

Transactions must bring the database from one valid state to another. Invalid data should not enter the system.

Alter

Isolation

Concurrent transactions should not affect each other’s intermediate results.

Isolation prevents dirty reads between transactions.

Durability

Atomicity → All or nothing.
Consistency→ Data always valid.
Isolation → Transactions don’t interfere.
Durability→ Data persists after commit.
By applying ACID principles, databases remain reliable, fault-tolerant, and consistent even in high-concurrency environments like banking systems

Transactions, Deadlocks & Log Based Recovery

NAHULESWARAN S 24CB031 — Fri, 10 Oct 2025 04:31:16 +0000

Managing database transactions safely is crucial to ensure data integrity and prevent issues like partial updates or deadlocks. In this tutorial, we’ll explore transactions, deadlocks, and log-based recovery using a simple Accounts table.

Let’s create a table

Insert values

Transaction – Atomicity & Rollback

ROLLBACK

UPDATE Accounts

Deadlock Simulation

Deadlocks occur when two transactions block each other waiting for resources.

RESULT
ERROR 1213 (40001): Deadlock found when trying to get lock; try restarting transaction

Log-Based Recovery

Modern DBMS (MySQL/PostgreSQL) automatically maintain transaction logs. These logs help undo changes if a transaction fails.

UPDATE Accounts

SELECT * FROM Accounts;

Summary

Transactions guarantee atomicity; either all operations succeed or none.
Deadlocks occur when transactions block each other; they must be handled with care.
Log-based recovery ensures durability and recoverability.

INDEXING - HASHING - AND -QUERY

NAHULESWARAN S 24CB031 — Fri, 10 Oct 2025 04:24:57 +0000

Mastering Indexing in SQL: B-Tree, B+Tree, and Hash Index Examples

Indexing is one of the most powerful ways to boost the performance of your SQL queries. In this tutorial, we’ll explore B-Tree, B+Tree, and Hash indexes step-by-step using a Students table example.

We’ll:
✅ Create a Students table
✅ Insert sample data
✅ Build three types of indexes
✅ Run queries using each index
✅ Observe how indexing improves retrieval speed

Create the Table

Insert Sample Records

Create a B-Tree Index on roll_no

Query Using the B-Tree Index

Query Using the B+ Tree Index

Query Using the Hash Index

Conclusion

In this blog, we learned how to:
-Create B-Tree, B+Tree, and Hash indexes
-Execute optimized queries
-Understand which index type fits which use case

Indexes make retrieval blazing fast but also consume storage and slow down updates slightly. So, always index wisely!