DEV Community: SANCHAYAA S 24CB052

🌱 Hands-on with MongoDB CRUD Operations:

SANCHAYAA S 24CB052 — Sat, 04 Oct 2025 15:12:35 +0000

🎯 Objective

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

MongoDB, a popular NoSQL database, stores data in flexible, JSON-like documents. This makes it ideal for projects that require scalability, real-time analytics, and easy data handling.

🧩 Schema Design

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

{
"student_id": "S001",
"name": "Sanchayaa",
"age": 20,
"department": "CSBS",
"year": 2,
"cgpa": 9
}
🔹 1️⃣ CREATE (Insert Data)

Let’s add 5 sample student records.
use collegeDB;

db.students.insertMany([
{ "student_id": "S001", "name": "San", "age": 20, "department": "CSBS", "year": 2, "cgpa": 9 },
{ "student_id": "S002", "name": "Meena", "age": 21, "department": "CSE", "year": 3, "cgpa": 8.5 },
{ "student_id": "S003", "name": "Arun", "age": 19, "department": "ECE", "year": 1, "cgpa": 7.2 },
{ "student_id": "S004", "name": "Divya", "age": 22, "department": "CSE", "year": 3, "cgpa": 9.1 },
{ "student_id": "S005", "name": "Vikram", "age": 20, "department": "MECH", "year": 2, "cgpa": 8 }
]);

🔹 2️⃣ READ (Query Data)
➤ Display all student records
db.students.find().pretty();

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

➤ Find students belonging to the Computer Science department
db.students.find({ department: "CSE" });

✅ Result: MongoDB displays only the filtered student documents that match the criteria.

🔹 3️⃣ UPDATE (Modify Data)
➤ Update the CGPA of a specific student
db.students.updateOne(
{ student_id: "S002" },
{ $set: { cgpa: 8.9 } }
);

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

✅ Result: CGPA updated and all third-year students promoted to the next year.
🔹 4️⃣ DELETE (Remove Data)
➤ Delete one student record by student_id
db.students.deleteOne({ student_id: "S005" });

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

✅ Result: Low-performing student records removed from the collection.

⚡ Mastering Indexing, Hashing & Query Optimization in SQL

SANCHAYAA S 24CB052 — Sat, 04 Oct 2025 13:47:10 +0000

🎯 Objective:
To gain hands-on experience with Indexing, Hashing, and Query Optimization techniques using Oracle SQL.
You’ll learn how different index types (B-Tree, B+ Tree, Hash) improve query performance.

🏗 Step 1: Create the Students Table

Let’s start with our base schema for the lab.
-- Drop old table if exists
BEGIN
EXECUTE IMMEDIATE 'DROP TABLE Students';
EXCEPTION
WHEN OTHERS THEN NULL;
END;
/

-- Create Students table
CREATE TABLE Students (
roll_no NUMBER PRIMARY KEY,
name VARCHAR2(50),
dept VARCHAR2(10),
cgpa NUMBER(3,2)
);
📥 Step 2: Insert Sample Data
INSERT INTO Students VALUES (101, 'Alice', 'CSBS', 8.5);
INSERT INTO Students VALUES (102, 'Bob', 'ECE', 7.8);
INSERT INTO Students VALUES (103, 'Charlie', 'ME', 8.2);
INSERT INTO Students VALUES (104, 'David', 'CSBS', 9.0);
INSERT INTO Students VALUES (105, 'Eva', 'ECE', 7.5);
INSERT INTO Students VALUES (106, 'Frank', 'ME', 8.1);
INSERT INTO Students VALUES (107, 'Grace', 'CSBS', 9.2);
INSERT INTO Students VALUES (108, 'Hannah', 'ECE', 6.9);
INSERT INTO Students VALUES (109, 'Ian', 'ME', 7.8);
INSERT INTO Students VALUES (110, 'Jack', 'CSBS', 8.8);
INSERT INTO Students VALUES (111, 'Karen', 'ECE', 8.0);
INSERT INTO Students VALUES (112, 'Leo', 'ME', 7.9);
INSERT INTO Students VALUES (113, 'Mona', 'CSBS', 8.7);
INSERT INTO Students VALUES (114, 'Nina', 'ECE', 8.3);
INSERT INTO Students VALUES (115, 'Oscar', 'ME', 7.6);
INSERT INTO Students VALUES (116, 'Paul', 'CSBS', 9.1);
INSERT INTO Students VALUES (117, 'Quinn', 'ECE', 8.4);
INSERT INTO Students VALUES (118, 'Rachel', 'ME', 7.7);
INSERT INTO Students VALUES (119, 'Steve', 'CSBS', 8.9);
INSERT INTO Students VALUES (120, 'Tina', 'ECE', 8.2);

COMMIT;
✅ Output:
20 student records successfully inserted.

🌳 Step 3: Creating a B-Tree Index

A B-Tree index helps optimize exact match and range queries.
In Oracle, the default index type is B-Tree.

CREATE INDEX idx_roll_no ON Students(roll_no);

Query using the B-Tree index:
SELECT * FROM Students WHERE roll_no = 110;

💬 Result:
Query runs faster — Oracle uses the idx_roll_no index instead of scanning the whole table.

🌲 Step 4: Creating a B+ Tree Index (on CGPA)

B+ Trees are used internally by Oracle for normal indexes.
They’re ideal for range-based queries (e.g., >, <, BETWEEN).

CREATE INDEX idx_cgpa ON Students(cgpa);

Query using B+ Tree index:
SELECT * FROM Students WHERE cgpa > 8.0 ORDER BY cgpa DESC;

✅ Why it’s faster:
Oracle reads index pages sequentially, avoiding full table scans.
Perfect for range conditions and sorting queries.

💠 Step 5: Simulating a Hash Index (on dept)

Oracle doesn’t allow direct USING HASH indexes on regular tables,
but we can use normal indexing to simulate hash-based performance for exact matches.

CREATE INDEX idx_dept ON Students(dept);

Query example:
SELECT * FROM Students WHERE dept = 'CSBS';

💬 Explanation:

Hashing is best for equality lookups (like dept = 'CSBS').

B-Tree is still used internally but acts similarly for single-value queries.

🔍 Step 6: Query Optimization with EXPLAIN PLAN

Let’s verify that Oracle uses our indexes.

EXPLAIN PLAN FOR
SELECT * FROM Students WHERE roll_no = 110;

SELECT * FROM TABLE(DBMS_XPLAN.DISPLAY);
These confirm that your query is optimized using indexes.

📊 Step 7: Understanding Index Types
Index Type Use Case Example Query Advantage
B-Tree Equality or range lookup
WHERE roll_no = 110 Balanced tree → fast lookup
B+ Tree Range or sorting queries
WHERE cgpa > 8 Optimized for sequential access

Transactions,Deadlocks and Log Based Recovery

SANCHAYAA S 24CB052 — Sat, 04 Oct 2025 13:35:21 +0000

💡 Objective:
To gain hands-on experience with ACID transactions, simulate deadlocks, and observe log-based recovery in a relational database system.

We’ll use a simple Accounts table to demonstrate these core database concept
CREATE TABLE Accounts (
acc_no INT PRIMARY KEY,
name VARCHAR(50),
balance INT
);

INSERT INTO Accounts VALUES
(1, 'Alice', 1000),
(2, 'Bob', 1500),
(3, 'Charlie', 2000);
Step 2: Transaction – Atomicity & Rollback

A transaction is a group of SQL operations executed as a single logical unit.
Let’s test Atomicity — “all or nothing” execution.

Example: Transfer ₹500 from Alice → Bob, then rollback.
-- Start a transaction
START TRANSACTION;

-- Debit Alice
UPDATE Accounts
SET balance = balance - 500
WHERE name = 'Alice';

-- Credit Bob
UPDATE Accounts
SET balance = balance + 500
WHERE name = 'Bob';

-- Rollback before committing
ROLLBACK;

-- Check balances
SELECT * FROM Accounts;

Step 3: Deadlock Simulation

A deadlock occurs when two transactions hold locks that the other needs.
Let’s simulate this using two SQL sessions.

🧩 Session 1
START TRANSACTION;

-- Lock Alice’s account
SELECT * FROM Accounts WHERE name='Alice' FOR UPDATE;

-- Try to update Bob’s balance (will wait if Session 2 has locked Bob)
UPDATE Accounts SET balance = balance + 100 WHERE name='Bob';

🧩 Session 2
START TRANSACTION;

-- Lock Bob’s account
SELECT * FROM Accounts WHERE name='Bob' FOR UPDATE;

-- Try to update Alice’s balance (will wait if Session 1 has locked Alice)
UPDATE Accounts SET balance = balance + 200 WHERE name='Alice';
🧨 Result:
Database detects a deadlock automatically and aborts one transaction.

Example Error (MySQL):

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

💬 Explanation:
Each session holds one lock and waits for the other.
To prevent deadlocks → access resources in the same order and keep transactions short.

🧾 Step 4: Log-Based Recovery

Modern databases maintain logs to record every transaction’s activity.
These logs allow the system to undo uncommitted changes and redo committed ones after a crash.

Example: Observe undo logging via rollback
-- Start a transaction
START TRANSACTION;

-- Update Charlie’s balance
UPDATE Accounts SET balance = balance + 500 WHERE name = 'Charlie';

-- Rollback
ROLLBACK;

-- Verify balance restored
SELECT * FROM Accounts WHERE name = 'Charlie';
✅ Result:
Charlie’s balance remains unchanged (2000).

💬 Explanation:
The database writes the undo log entry when you start the transaction.
When rollback is issued, the DB uses that log to restore previous values

To demonstrate the ACID properties (Atomicity, Consistency, Isolation, and Durability) using SQL transactions.

SANCHAYAA S 24CB052 — Sat, 04 Oct 2025 13:28:19 +0000

🧩 Step 1: Create Table and Insert Sample Data
BEGIN
EXECUTE IMMEDIATE 'DROP TABLE ACCOUNTS CASCADE CONSTRAINTS';
EXCEPTION WHEN OTHERS THEN NULL;
END;
/

CREATE TABLE ACCOUNTS (
acc_no INT PRIMARY KEY,
name VARCHAR2(50),
balance INT CHECK (balance >= 0)
);

INSERT INTO ACCOUNTS VALUES (101, 'Kiran', 5000);
INSERT INTO ACCOUNTS VALUES (102, 'Asha', 7000);
INSERT INTO ACCOUNTS VALUES (103, 'Vikram', 9000);
COMMIT;

-- ✅ View initial data
SELECT * FROM ACCOUNTS;

Step 2: Atomicity

Atomicity means “all or nothing.”
If a transaction fails, no partial updates remain.

🧪 Example: Transfer ₹1000 from Kiran to Asha, but rollback halfway
-- Start transaction
SAVEPOINT start_transfer;

UPDATE ACCOUNTS SET balance = balance - 1000 WHERE acc_no = 101;
UPDATE ACCOUNTS SET balance = balance + 1000 WHERE acc_no = 102;

-- Suppose error happens — rollback
ROLLBACK TO start_transfer;

-- ✅ Check balances after rollback
SELECT * FROM ACCOUNTS;
✅ Output
No change! Balances are the same as before → proves Atomicity.

Step 3: Consistency

Consistency means the database always stays valid — rules and constraints are never broken.

🧪 Example: Try inserting an invalid record
-- This should FAIL because of the CHECK constraint
INSERT INTO ACCOUNTS VALUES (104, 'Sneha', -2000);

🧱 Expected Result:

ORA-02290: check constraint (BALANCE >= 0) violated

✅ Database rejected invalid data → proves Consistency.
Step 4: Isolation

Isolation means one transaction’s changes are not visible to others until committed.

We can simulate this conceptually (since Oracle Live SQL runs one session per user):

Session 1 (Transaction A):

-- Begin Transaction A
UPDATE ACCOUNTS SET balance = balance - 500 WHERE acc_no = 101;

-- Don’t commit yet

Session 2 (Transaction B):

-- Try reading while Transaction A is open
SELECT * FROM ACCOUNTS WHERE acc_no = 101;

✅ Observation:
Transaction B still sees the old balance (not updated)
→ changes are isolated until commit.

Then, if Session 1 commits:

COMMIT;

Now Session 2 reads:

SELECT * FROM ACCOUNTS WHERE acc_no = 101;

✅ Now it sees the new value → proves Isolation.

🔒 Step 5: Durability

Durability means once a transaction is committed, it survives system failure.

🧪 Example:
UPDATE ACCOUNTS SET balance = balance + 500 WHERE acc_no = 103;
COMMIT;

✅ Even if the database restarts or session closes, the committed change stays stored permanently.
If you re-run:

SELECT * FROM ACCOUNTS WHERE acc_no = 103;

Cursor and Trigger

SANCHAYAA S 24CB052 — Sat, 04 Oct 2025 12:53:16 +0000

🔹 Cursor

A cursor is like a pointer that goes through each row of a query result one at a time.

We’ll create a cursor to:

Display employee names whose salary is greater than 50,000.

🔹 Trigger

A trigger is like an automatic reaction —
It executes automatically when an event (INSERT/UPDATE/DELETE) happens on a table.

We’ll create an AFTER INSERT trigger to:

Automatically insert a record into a Student_Audit table whenever a new student is added to the Students table.
✅ Step 1: Create the Employee Table
-- Drop if already exists
BEGIN
EXECUTE IMMEDIATE 'DROP TABLE EMPLOYEE';
EXCEPTION WHEN OTHERS THEN NULL;
END;
/

CREATE TABLE EMPLOYEE (
EmpID NUMBER PRIMARY KEY,
EmpName VARCHAR2(50),
Salary NUMBER
);

INSERT INTO EMPLOYEE VALUES (1, 'Kiran', 45000);
INSERT INTO EMPLOYEE VALUES (2, 'Asha', 52000);
INSERT INTO EMPLOYEE VALUES (3, 'Sneha', 60000);
INSERT INTO EMPLOYEE VALUES (4, 'Rahul', 40000);
INSERT INTO EMPLOYEE VALUES (5, 'Vikram', 80000);

COMMIT;

✅ Step 2: Create the Cursor Block

Now we’ll write a PL/SQL block that uses a cursor to process rows conditionally.
SET SERVEROUTPUT ON;

DECLARE
-- Cursor declaration
CURSOR emp_cursor IS
SELECT EmpName, Salary
FROM EMPLOYEE
WHERE Salary > 50000;

-- Variables to store each row
v_name EMPLOYEE.EmpName%TYPE;
v_salary EMPLOYEE.Salary%TYPE;

BEGIN
OPEN emp_cursor;
LOOP
FETCH emp_cursor INTO v_name, v_salary;
EXIT WHEN emp_cursor%NOTFOUND;

    DBMS_OUTPUT.PUT_LINE('Employee: ' || v_name || ' | Salary: ' || v_salary);
END LOOP;
CLOSE emp_cursor;

END;
/

🎯 Output (on Oracle Live SQL console)
Employee: Asha | Salary: 52000
Employee: Sneha | Salary: 60000
Employee: Vikram | Salary: 80000

Trigger Example — AFTER INSERT on Students Table
✅ Step 1: Create Student and Audit Tables
BEGIN
EXECUTE IMMEDIATE 'DROP TABLE STUDENT_AUDIT';
EXECUTE IMMEDIATE 'DROP TABLE STUDENTS';
EXCEPTION WHEN OTHERS THEN NULL;
END;
/

CREATE TABLE STUDENTS (
StudentID NUMBER PRIMARY KEY,
StudentName VARCHAR2(50),
Course VARCHAR2(50)
);

CREATE TABLE STUDENT_AUDIT (
AuditID NUMBER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
StudentID NUMBER,
StudentName VARCHAR2(50),
ActionDate DATE,
ActionType VARCHAR2(20)
);

✅ Step 2: Create the Trigger
CREATE OR REPLACE TRIGGER trg_student_insert
AFTER INSERT ON STUDENTS
FOR EACH ROW
BEGIN
INSERT INTO STUDENT_AUDIT (StudentID, StudentName, ActionDate, ActionType)
VALUES (:NEW.StudentID, :NEW.StudentName, SYSDATE, 'INSERT');
END;
/

Explanation:

AFTER INSERT ON STUDENTS → runs after a new student is inserted.

:NEW → refers to the new row being added.

Automatically logs into the STUDENT_AUDIT table.

Database Normalization Explained with SQL Examples (1NF, 2NF, 3NF)

SANCHAYAA S 24CB052 — Sat, 04 Oct 2025 11:17:57 +0000

When working with databases, one of the biggest challenges is data redundancy and anomalies (insertion, update, deletion problems).
This is where Normalization comes in — a process of organizing data into efficient structures.

🔎 Step 1: Identifying Anomalies

This table has multiple issues:

1)Insertion anomaly – Can’t add a new course unless a student enrolls.
2)Update anomaly – If Dr. Kumar’s phone number changes, we must update it in multiple rows.
3)Deletion anomaly– If the last student in a course is removed, we lose course and instructor details too.

Clearly, normalization is needed.

✅ 1NF (First Normal Form)

Rule:1 Data must be atomic, no repeating groups.

Our base table is already in 1NF, since each column has atomic values.
But redundancy still exists.

SQL (1NF structure):

CREATE TABLE StudentCourse1NF (
StudentID VARCHAR(10),
StudentName VARCHAR(50),
CourseID VARCHAR(10),
CourseName VARCHAR(50),
Instructor VARCHAR(50),
InstructorPhone VARCHAR(15),
PRIMARY KEY (StudentID, CourseID)
);
✅ 2NF (Second Normal Form)

Rule: Must be in 1NF + no partial dependency.

Problem in 1NF:

StudentName depends only on StudentID.
CourseName, Instructor, and InstructorPhone depend only on CourseID.

👉 Solution: Split into Student, Course, and Enrollment tables.

SQL for 2NF:

CREATE TABLE Student (
StudentID VARCHAR(10) PRIMARY KEY,
StudentName VARCHAR(50)
);

CREATE TABLE Course (
CourseID VARCHAR(10) PRIMARY KEY,
CourseName VARCHAR(50),
Instructor VARCHAR(50),
InstructorPhone VARCHAR(15)
);

CREATE TABLE Enrollment (
StudentID VARCHAR(10),
CourseID VARCHAR(10),
PRIMARY KEY (StudentID, CourseID),
FOREIGN KEY (StudentID) REFERENCES Student(StudentID),
FOREIGN KEY (CourseID) REFERENCES Course(CourseID)
);

✅ 3NF (Third Normal Form)

Rule: Must be in 2NF + no transitive dependency.

Problem in 2NF:

In Course, InstructorPhone depends on Instructor, not directly on CourseID.

👉 Solution: Create a separate Instructor table.

SQL for 3NF:
CREATE TABLE Student (
StudentID VARCHAR(10) PRIMARY KEY,
StudentName VARCHAR(50)
);

CREATE TABLE Instructor (
InstructorID VARCHAR(10) PRIMARY KEY,
InstructorName VARCHAR(50),
InstructorPhone VARCHAR(15)
);

CREATE TABLE Course (
CourseID VARCHAR(10) PRIMARY KEY,
CourseName VARCHAR(50),
InstructorID VARCHAR(10),
FOREIGN KEY (InstructorID) REFERENCES Instructor(InstructorID)
);

-- Students
INSERT INTO Student VALUES ('S01', 'Arjun');
INSERT INTO Student VALUES ('S02', 'Priya');
INSERT INTO Student VALUES ('S03', 'Kiran');

-- Instructors
INSERT INTO Instructor VALUES ('I01', 'Dr. Kumar', '9876543210');
INSERT INTO Instructor VALUES ('I02', 'Dr. Mehta', '9123456780');
INSERT INTO Instructor VALUES ('I03', 'Dr. Rao', '9988776655');

-- Courses
INSERT INTO Course VALUES ('C101', 'DBMS', 'I01');
INSERT INTO Course VALUES ('C102', 'Data Mining', 'I02');
INSERT INTO Course VALUES ('C103', 'AI', 'I03');

-- Enrollment
INSERT INTO Enrollment VALUES ('S01', 'C101');
INSERT INTO Enrollment VALUES ('S01', 'C102');
INSERT INTO Enrollment VALUES ('S02', 'C101');
INSERT INTO Enrollment VALUES ('S03', 'C103');

📌 Query: Students with Courses and Instructors

SELECT s.StudentName, c.CourseName, i.InstructorName
FROM Enrollment e
JOIN Student s ON e.StudentID = s.StudentID
JOIN Course c ON e.CourseID = c.CourseID
JOIN Instructor i ON c.InstructorID = i.InstructorID;

🎯 Key Takeaways

1NF removes repeating groups.
2NF removes partial dependency.
3NF removes transitive dependency.
Normalization reduces redundancy and prevents anomalies.

By splitting large tables into smaller, well-structured ones, we ensure cleaner data, better performance, and easier maintenance.

College Student and Course Management System

SANCHAYAA S 24CB052 — Thu, 21 Aug 2025 10:01:17 +0000

Managing students, courses, and faculty is one of the most common use cases for a Database Management System (DBMS). In this blog, we’ll walk through how to build a mini Student & Course Management System using SQL.

By the end, you’ll learn:
✅ How to create tables (DDL)
✅ How to insert data (DML)
✅ How to update & delete data
✅ How to query and join tables for insights
✅ How to make your system practical & interesting

🏫 Step 1: Creating the Database

Let’s start by creating our database.

CREATE DATABASE CollegeDB;
USE CollegeDB;

👩‍🎓 Step 2: Creating the Tables

We’ll need 3 main tables:

Students – to store student details
Courses – to store course details
Enrollments – to link students with courses

Students Table
CREATE TABLE Students (
StudentID INT PRIMARY KEY AUTO_INCREMENT,
StudentName VARCHAR(100) NOT NULL,
Department VARCHAR(50),
Email VARCHAR(100) UNIQUE,
PhoneNo VARCHAR(15)
);

-- Courses Table
CREATE TABLE Courses (
CourseID INT PRIMARY KEY AUTO_INCREMENT,
CourseName VARCHAR(100) NOT NULL,
Credits INT NOT NULL
);

-- Enrollments Table (Relationship)
CREATE TABLE Enrollments (
EnrollmentID INT PRIMARY KEY AUTO_INCREMENT,
StudentID INT,
CourseID INT,
Semester VARCHAR(10),
Grade CHAR(2),
FOREIGN KEY (StudentID) REFERENCES Students(StudentID),
FOREIGN KEY (CourseID) REFERENCES Courses(CourseID)
);

📝 Step 3: Inserting Data

Let’s add some sample students and courses.

-- Insert Students
INSERT INTO Students (StudentName, Department, Email, PhoneNo) VALUES
('Rahul Kumar', 'Computer Science', 'rahul@college.edu', '9876543210'),
('Priya Sharma', 'Commerce', 'priya@college.edu', '9876501234'),
('Amit Verma', 'Mechanical', 'amit@college.edu', '9876523456');

-- Insert Courses
INSERT INTO Courses (CourseName, Credits) VALUES
('Database Management', 4),
('Computer Networks', 3),
('Financial Accounting', 4),
('Thermodynamics', 3);

-- Enroll Students into Courses
INSERT INTO Enrollments (StudentID, CourseID, Semester, Grade) VALUES
(1, 1, 'Sem1', 'A'),
(1, 2, 'Sem1', 'B'),
(2, 3, 'Sem2', 'A'),
(3, 4, 'Sem1', 'B');

🔍 Step 4: Querying the Database

Now the fun part – let’s ask our database questions!

Show all students
SELECT * FROM Students;
Find all courses taken by Rahul Kumar
SELECT s.StudentName, c.CourseName, e.Semester, e.Grade
FROM Enrollments e
JOIN Students s ON e.StudentID = s.StudentID
JOIN Courses c ON e.CourseID = c.CourseID
WHERE s.StudentName = 'Rahul Kumar';
Count how many students are in each department
SELECT Department, COUNT(*) AS TotalStudents
FROM Students
GROUP BY Department;
Find top performers (students with Grade 'A')
SELECT s.StudentName, c.CourseName, e.Grade
FROM Enrollments e
JOIN Students s ON e.StudentID = s.StudentID
JOIN Courses c ON e.CourseID = c.CourseID
WHERE e.Grade = 'A';

⚡ Step 5: Updating & Deleting Data

Rahul changed his phone number? Let’s update it.

UPDATE Students
SET PhoneNo = '9998887776'
WHERE StudentName = 'Rahul Kumar';

Want to remove a student completely?
DELETE FROM Students
WHERE StudentID = 3;

🎯 Step 6: Why This System Matters

This Student & Course Management System is not just a practice project — it’s the foundation of real-world college ERP systems.

Colleges use it to manage admissions, courses, results, and fees.
You can extend it with features like faculty details, attendance tracking, and exam results.
Add a web or app interface and you’ve got a full-fledged college management software!

🚀 Final Thoughts

We just built a mini college ERP system using SQL. You now know how to:
✔ Create and link tables
✔ Insert, update, and delete data
✔ Query with joins and conditions
✔ Extract insights from your database

This project is a perfect mini-project for college students in DBMS, SQL, or Software Engineering courses.