DEV Community: Boopathy.S

AWS SERVICES

Boopathy.S — Thu, 18 Dec 2025 14:01:04 +0000

Amazon Bedrock: Building Generative AI Applications on AWS

As cloud computing evolves, Generative AI has become a key component in modern applications. AWS addresses this need with Amazon Bedrock, a fully managed service that makes it easy to build, deploy, and scale generative AI solutions without managing infrastructure.

What is Amazon Bedrock?

Amazon Bedrock is a serverless AWS service that provides access to high-performance foundation models (FMs) from leading AI providers such as Amazon (Titan), Anthropic, Meta, and Mistral through a single API. It enables developers to integrate generative AI capabilities into applications securely and efficiently.

Key Features

Multiple Foundation Models via one unified API

Serverless Architecture – no infrastructure management

Enterprise-grade security and compliance

Easy model customization and fine-tuning

Seamless integration with AWS services like S3, IAM, CloudWatch

Supports text generation, chatbots, summarization, and image creation

AWS Category / Cloud Domain

Artificial Intelligence & Machine Learning

Generative AI

Application Development

Where It Fits in the Cloud / DevOps Lifecycle

Lifecycle Phase Role of Amazon Bedrock

Planning - Choosing AI models for business use cases
Development - Building AI-powered applications
Testing - Prompt testing and response tuning
Deployment - Serverless deployment of AI features
Monitoring - Performance tracking using CloudWatch
Scaling - Automatic scaling handled by AWS

Amazon Bedrock fits perfectly into cloud-native and DevOps workflows, allowing teams to innovate faster without worrying about infrastructure.

Programming Languages / Access Methods

Supported Programming Languages
Python
Java
JavaScript (Node.js)

Access Methods:
AWS SDKs
AWS CLI
REST APIs

AWS Management Console

Pricing Model

Amazon Bedrock follows a pay-as-you-go pricing model:

Charged based on input tokens and output tokens

No upfront or fixed infrastructure costs

Pricing varies depending on the foundation model selected

This makes Bedrock cost-effective and scalable for startups and enterprises alike.

Why Choose Amazon Bedrock?

No need for deep ML expertise
Faster time-to-market for AI applications
Secure, scalable, and AWS-native
Ideal for DevOps and cloud engineers exploring AI integration

Conclusion

Amazon Bedrock simplifies the adoption of generative AI by providing powerful models in a fully managed, secure, and scalable environment. For developers and DevOps teams looking to integrate AI into cloud applications, Amazon Bedrock is a game-changing AWS service.
THANK YOU @santhoshnc sir for encouraging me.

DevSecOps Periodic Table

Boopathy.S — Thu, 18 Dec 2025 13:41:23 +0000

BigPanda in the DevSecOps Periodic Table

In modern DevOps and DevSecOps environments, teams deal with thousands of alerts, logs, and monitoring signals every day. Without proper intelligence, this noise can slow down response times and increase system downtime.
This is where BigPanda plays a crucial role.

BigPanda is widely recognized as an AIOps (Artificial Intelligence for IT Operations) platform that helps organizations transform raw alert data into meaningful, actionable incidents.

Overview of BigPanda:

BigPanda is an AI-powered IT Operations and incident management platform designed to reduce alert noise, correlate events, and speed up incident resolution.

Instead of engineers manually analyzing alerts from multiple monitoring tools, BigPanda automatically groups related alerts into a single incident, enriched with context such as topology, changes, and historical data.

Key Features:

BigPanda provides several powerful features that make it valuable in DevOps and DevSecOps pipelines:

AI-Driven Event Correlation

BigPanda uses machine learning to correlate alerts from different sources and identify the real issue behind them.

Alert Noise Reduction

Thousands of alerts are compressed into a few meaningful incidents, helping engineers focus on what truly matters.

Automated Incident Triage

Incidents are automatically classified, tagged, and routed to the right teams, reducing manual effort.

Root Cause Analysis (RCA)

BigPanda helps identify the most likely root cause by analyzing dependencies and past incidents.

Seamless Integrations

It integrates with popular tools like:
ServiceNow
Jira
PagerDuty
Datadog
Prometheus
Splunk

Workflow Automation

Automates repetitive tasks such as ticket creation, notifications, and incident escalation.

How BigPanda Fits into DevOps & DevSecOps

In a DevOps pipeline, BigPanda acts as the intelligence layer between monitoring tools and response teams.

In DevOps:

Improves incident response time (MTTR)

Reduces operational toil for SREs and developers

Provides visibility across distributed systems

In DevSecOps:

Helps identify incidents caused by misconfigurations or risky deployments

Improves collaboration between DevOps, SecOps, and IT teams

Supports proactive security posture by analyzing incident patterns

BigPanda ensures that security and reliability issues are detected early and handled efficiently, aligning perfectly with DevSecOps principles.

Programming Languages & Technology
BigPanda’s core platform is built using Java

Runs on Linux-based infrastructure

Uses a domain-specific language called BPQL (BigPanda Query Language) for querying and incident analysis

Provides APIs and integrations for automation and extensibility

Parent Company

Company Name: BigPanda Inc.

Founded: 2012

Headquarters: Redwood City, California, USA

Type: Private company

BigPanda operates independently and focuses on enterprise-scale IT operations and AIOps innovation.

Open Source or Paid?

Not Open Source

Paid SaaS Product

BigPanda is a commercial, enterprise-grade SaaS platform offered through subscription-based pricing.
It is primarily targeted at medium to large organizations managing complex infrastructures. THANK YOU @santhoshnc sir for updating my knowledge !!

CRUD Operations in MongoDB: with a Student Collection

Boopathy.S — Sat, 04 Oct 2025 06:24:14 +0000

MongoDB is a NoSQL document database that stores data in JSON-like documents. In this tutorial, we’ll perform CRUD operations using a simple college student schema.

1️⃣ Create (Insert)
Schema:
Student 1
{
"student_id": "S001",
"name": "Pranav",
"age": 20,
"department": "CSBS",
"year": 2,
"cgpa": 9
}
Student 2
{
"student_id": "S002",
"name": "Sashmi",
"age": 21,
"department": "CSE",
"year": 3,
"cgpa": 8.5
}
Student 3
{
"student_id": "S003",
"name": "Diksha",
"age": 22,
"department": "ECE",
"year": 4,
"cgpa": 7.2
}
Student 4
{
"student_id": "S004",
"name": "Prian",
"age": 19,
"department": "CSBS",
"year": 1,
"cgpa": 9.3
}
Student 5
{
"student_id": "S005",
"name": "Harini",
"age": 20,
"department": "Mechanical",
"year": 2,
"cgpa": 6.8
}
Screenshot:

2️⃣Read (Query)

A.Display all students
{}

B.Students with CGPA > 8

{ "cgpa": { "$gt": 8 } }

C.Students in CSBS department

{ "department": { "$in": ["CSBS"] } }

3️⃣Update

A.Update CGPA of a specific student (S002)
{ "student_id": "S002" }

B. Increase year of all 3rd year students by 1
{ "year": 3 }

4️⃣Delete

A. Delete one student by student_id (S005)

{ "student_id": "S004" }

B. Delete all students with CGPA < 7.5

{ "cgpa": { "$lt": 7.5 } }

✅ Summary:
Operation MongoDB Query
Create insertOne / insertMany
Read find()
Update updateOne / updateMany
Delete deleteOne / deleteMany

MongoDB allows flexible, schema-less data storage, making it ideal for applications requiring rapid iteration and scalability.

Thank You @santhoshnc sir for guiding me!!!

Indexing, Hashing & Query Optimization in liveSQL

Boopathy.S — Sat, 04 Oct 2025 02:40:37 +0000

Indexes are one of the most powerful tools in SQL databases for improving query performance. In this blog, we’ll explore B-Tree Index, B+ Tree Index, and Hash Index using a simple Students table in Oracle LiveSQL.

Step 1: Create the Students Table
We start by creating a table Students with roll number, name, department, and CGPA fields.

CREATE TABLE Students (
ROLL_NO NUMBER PRIMARY KEY,
NAME VARCHAR2(50),
DEPT VARCHAR2(20),
CGPA NUMBER(3,2)
);

Step 2: Insert Sample Records
Let’s add 20 students across different departments with varying CGPAs.
INSERT INTO Students VALUES (101, 'Alice', 'CSBS', 8.5);
INSERT INTO Students VALUES (102, 'Bob', 'ECE', 7.9);
INSERT INTO Students VALUES (103, 'Charlie', 'MECH', 8.2);
INSERT INTO Students VALUES (104, 'David', 'CIVIL', 7.0);
INSERT INTO Students VALUES (105, 'Eva', 'CSBS', 9.0);
INSERT INTO Students VALUES (106, 'Frank', 'EEE', 6.8);
INSERT INTO Students VALUES (107, 'Grace', 'ECE', 8.3);
INSERT INTO Students VALUES (108, 'Hank', 'MECH', 7.2);
INSERT INTO Students VALUES (109, 'Ivy', 'CIVIL', 8.1);
INSERT INTO Students VALUES (110, 'Jack', 'CSBS', 9.0);
INSERT INTO Students VALUES (111, 'Kim', 'EEE', 7.5);
INSERT INTO Students VALUES (112, 'Leo', 'CSBS', 9.2);
INSERT INTO Students VALUES (113, 'Mia', 'MECH', 6.9);
INSERT INTO Students VALUES (114, 'Nina', 'ECE', 8.7);
INSERT INTO Students VALUES (115, 'Oscar', 'CSBS', 9.4);
INSERT INTO Students VALUES (116, 'Paul', 'EEE', 7.8);
INSERT INTO Students VALUES (117, 'Quinn', 'MECH', 8.0);
INSERT INTO Students VALUES (118, 'Rose', 'CIVIL', 7.3);
INSERT INTO Students VALUES (119, 'Sam', 'ECE', 8.8);
INSERT INTO Students VALUES (120, 'Tina', 'CSBS', 9.1);

Step 3: Create a B-Tree Index on ROLL_NO
In Oracle, normal indexes are B-Tree indexes by default. They work best for equality lookups and range queries.
CREATE INDEX idx_rollno_btree ON Students(ROLL_NO);
SELECT * FROM Students WHERE ROLL_NO = 110;
Output → Jack, CSBS, 9.0

Step 4: Create a B+ Tree Index on CGPA
Oracle internally uses B-Trees, but when scanning ranges, they behave like B+ Trees.
CREATE INDEX idx_cgpa_bplus ON Students(CGPA);

SELECT * FROM Students WHERE CGPA > 8.0;
This retrieves all students who scored above 8.0 CGPA

Step 5: Create a Hash Index on DEPT
Oracle does not directly support USING HASH like PostgreSQL, but we can still create a normal index on the department column. This behaves like a hash lookup for equality searches.
CREATE INDEX idx_dept_hash ON Students(DEPT);
SELECT * FROM Students WHERE DEPT = 'CSBS';

Summary:
B-Tree Index → Great for ROLL_NO = 110 or ROLL_NO BETWEEN 101 AND 110.
B+ Tree Index → Works best for range queries (CGPA > 8.0).
Hash Index (simulated) → Best for equality checks (DEPT = 'CSBS').

THANK YOU @santhoshnc sir for guiding mee!!!

Transactions, Deadlocks & Log-Based Recovery in MySQL

Boopathy.S — Sat, 04 Oct 2025 02:24:32 +0000

In this blog, we’ll explore these concepts hands-on using MySQL with a simple Accounts table.

-- Create a new database
CREATE DATABASE IF NOT EXISTS BankDB;
USE BankDB;

-- Drop table if it already exists
DROP TABLE IF EXISTS Accounts;

-- Create Accounts table
CREATE TABLE Accounts (
acc_no INT PRIMARY KEY,
name VARCHAR(50),
balance INT
);

-- Insert sample records
INSERT INTO Accounts (acc_no, name, balance) VALUES
(1, 'Alice', 1000),
(2, 'Bob', 1500),
(3, 'Charlie', 2000);

-- View initial data
SELECT * FROM Accounts;

✅ Output:
acc_no name balance
1 Alice 1000
2 Bob 1500
3 Charlie 2000

1️⃣ Transaction – Atomicity & Rollback
Transactions should be atomic: either all operations succeed or none.
-- Start transaction
START TRANSACTION;

-- Transfer 500 from Alice to Bob
UPDATE Accounts SET balance = balance - 500 WHERE name = 'Alice';
UPDATE Accounts SET balance = balance + 500 WHERE name = 'Bob';

-- Rollback the transaction
ROLLBACK;

-- Check balances (unchanged)
SELECT * FROM Accounts;

2️⃣ Deadlock Simulation
Deadlocks happen when two transactions wait indefinitely for each other’s locks.
Open two sessions and run:

Session 1:
START TRANSACTION;
-- Lock Alice
SELECT * FROM Accounts WHERE name='Alice' FOR UPDATE;
-- Try updating Bob
UPDATE Accounts SET balance = balance + 10 WHERE name='Bob';

Session 2:
START TRANSACTION;
-- Lock Bob
SELECT * FROM Accounts WHERE name='Bob' FOR UPDATE;
-- Try updating Alice
UPDATE Accounts SET balance = balance + 20 WHERE name='Alice';

MySQL detects the deadlock and forces one session to fail:
ERROR 1213 (40001): Deadlock found when trying to get lock; try restarting transaction

3️⃣ Log-Based Recovery
MySQL uses binary logs (redo logs) and undo logs to maintain data consistency.
Let’s test rollback with logs:
-- Start transaction
START TRANSACTION;
-- Update Charlie’s balance
UPDATE Accounts SET balance = balance + 300 WHERE name = 'Charlie';
-- Rollback instead of commit
ROLLBACK;
-- Verify balance is unchanged
SELECT * FROM Accounts;
Charlie’s balance remains 2000 → MySQL’s undo logs restored the previous state.

Summary
Atomicity: Rollback ensures no partial updates.
Deadlocks: MySQL automatically detects and resolves them.
Log-Based Recovery: Undo/redo logs guarantee data consistency even after crashes.
With this, we’ve successfully demonstrated transactions, deadlock handling, and recovery in MySQL.

THANK YOU @santhoshnc sir for guiding me!!!

Understanding ACID Properties with SQL Transactions

Boopathy.S — Sat, 04 Oct 2025 02:12:15 +0000

In this blog, we will learn about Atomicity, Consistency, Isolation, and Durability using a simple SQL example with screenshots.

We’ll use an Accounts table to demonstrate each property step by step.

CREATE TABLE Accounts (
acc_no INT PRIMARY KEY,
name VARCHAR(50),
balance INT CHECK (balance >= 0) -- prevents negative balance
);
INSERT INTO Accounts VALUES (101, 'pranav', 5000);
INSERT INTO Accounts VALUES (102, 'sashmi', 3000);
INSERT INTO Accounts VALUES (103, 'harini', 7000);

SELECT * FROM Accounts;

Atomicity
Atomicity means all or nothing — if part of a transaction fails, the entire operation is rolled back.

START TRANSACTION;

UPDATE Accounts SET balance = balance - 1000 WHERE acc_no = 101;
UPDATE Accounts SET balance = balance + 1000 WHERE acc_no = 102;
-- Cancel the transaction
ROLLBACK;

SELECT * FROM Accounts;
The balances remain unchanged after rollback.

Consistency
Consistency ensures rules/constraints are never broken.
Since we defined CHECK (balance >= 0), inserting a negative balance will fail.

INSERT INTO Accounts VALUES (104, 'David', -2000);
we will see error like:
ERROR: CHECK constraint failed: Accounts
→ proves Consistency

Isolation
Isolation ensures transactions don’t interfere with each other.
Let’s simulate two sessions:
Session 1
START TRANSACTION;
UPDATE Accounts SET balance = balance - 500 WHERE acc_no = 101;
-- Don’t commit yet
Session 2
SELECT * FROM Accounts WHERE acc_no = 101;

If your DB uses READ COMMITTED (default in many systems), Session 2 still sees the old balance.
Once Session 1 does COMMIT;, Session 2 can see the updated value.

Durability
Durability guarantees that once a transaction is committed, it survives even after a crash/restart.

-- Commit a change
START TRANSACTION;
UPDATE Accounts SET balance = balance + 2000 WHERE acc_no = 103;
COMMIT;

-- Restart the DB server manually
-- Then check again
SELECT acc_no, name, balance FROM Accounts WHERE acc_no = 103;

THANK YOU @santhoshnc sir for guiding me!!!

SQL Cursors and Triggers:-

Boopathy.S — Sat, 04 Oct 2025 02:00:41 +0000

In this blog, we’ll explore two important SQL concepts: Cursors and Triggers, with hands-on examples.

1️⃣ Using a Cursor with a Condition
A cursor allows you to process rows returned by a query one at a time.
Here, we’ll display the names of employees whose salary is greater than 50,000 from the Employee table.

Step 1: Create Employee Table & Insert Sample Data
CREATE TABLE Employee (
EmpID INT PRIMARY KEY,
EmpName VARCHAR2(50),
Salary NUMBER
);
INSERT INTO Employee VALUES (101, 'Arjun', 60000);
INSERT INTO Employee VALUES (102, 'Priya', 45000);
INSERT INTO Employee VALUES (103, 'Kiran', 70000);

Step 2: Declare and Use Cursor
DECLARE
CURSOR emp_cursor IS
SELECT EmpName, Salary FROM Employee WHERE Salary > 50000;
emp_record emp_cursor%ROWTYPE;
BEGIN
OPEN emp_cursor;
LOOP
FETCH emp_cursor INTO emp_record;
EXIT WHEN emp_cursor%NOTFOUND;
DBMS_OUTPUT.PUT_LINE('Employee: ' || emp_record.EmpName || ', Salary: ' || emp_record.Salary);
END LOOP;
CLOSE emp_cursor;
END;
/

2️⃣ AFTER INSERT Trigger Example
A trigger is a stored procedure that is automatically executed in response to certain events.
Here, we’ll log every new student added to the Students table into a Student_Audit table.

Step 1: Create Students and Student_Audit Tables

CREATE TABLE Students (
StudentID VARCHAR2(10) PRIMARY KEY,
StudentName VARCHAR2(50)
);
CREATE TABLE Student_Audit (
AuditID INT GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
StudentID VARCHAR2(10),
StudentName VARCHAR2(50),
ActionDate TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);
Step 2: Create AFTER INSERT Trigger
CREATE OR REPLACE TRIGGER trg_student_insert
AFTER INSERT ON Students
FOR EACH ROW
BEGIN
INSERT INTO Student_Audit (StudentID, StudentName)
VALUES (:NEW.StudentID, :NEW.StudentName);
END;
/
Step 3: Test the Trigger
INSERT INTO Students (StudentID, StudentName) VALUES ('S01', 'Arjun');
INSERT INTO Students (StudentID, StudentName) VALUES ('S02', 'Priya');

SELECT * FROM Student_Audit;

![ ](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/pvh481m72hgteqgfzgou.png

Summary
Cursors: Useful to process query results row by row.
Triggers: Automatically execute actions on INSERT, UPDATE, or DELETE events.
Together, they allow you to implement row-level processing and automated logging in SQL.

THANK YOU @santhoshnc sir for guiding me!!!

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

Boopathy.S — Sat, 04 Oct 2025 01:38:40 +0000

In this post, we will learn about 1NF, 2NF, and 3NF with SQL examples. We’ll start with a denormalized base table and gradually normalize it step by step.

Bae Table:

Anomalies in Base Table
Insertion Anomaly: Can’t add a new course until a student registers.
Update Anomaly: If Prof. Smith changes name → must update multiple rows.
Deletion Anomaly: If Alice drops all courses → course info is lost.

First Normal Form (1NF)
Rule: Remove repeating groups and ensure atomic values.
In our base table, values are already atomic, so 1NF just looks like this:
CREATE TABLE StudentCourse (
StudentID VARCHAR(10),
StudentName VARCHAR(50),
CourseID VARCHAR(10),
CourseName VARCHAR(50),
InstructorName VARCHAR(50),
PRIMARY KEY (StudentID, CourseID)
);

Second Normal Form (2NF)
Rule: Eliminate partial dependency (non-key attributes should depend on the whole primary key).
Here, StudentName depends only on StudentID.
CourseName and InstructorName depend only on CourseID.
So, we split into three tables:
-- Students Table
CREATE TABLE Students (
StudentID VARCHAR(10) PRIMARY KEY,
StudentName VARCHAR(50)
);

-- Courses Table
CREATE TABLE Courses (
CourseID VARCHAR(10) PRIMARY KEY,
CourseName VARCHAR(50),
InstructorName VARCHAR(50)
);

Third Normal Form (3NF)
👉 Rule: Remove transitive dependency (non-key attribute depending on another non-key).
InstructorName depends on CourseID, but instructor details should be separate.
So, we restructure:
-- Students Table
CREATE TABLE Students (
StudentID VARCHAR(10) PRIMARY KEY,
StudentName VARCHAR(50)
);

-- Instructors Table
CREATE TABLE Instructors (
InstructorID VARCHAR(10) PRIMARY KEY,
InstructorName VARCHAR(50)
);

-- Courses Table
CREATE TABLE Courses (
CourseID VARCHAR(10) PRIMARY KEY,
CourseName VARCHAR(50),
InstructorID VARCHAR(10),
FOREIGN KEY (InstructorID) REFERENCES Instructors(InstructorID)
);

-- Relationship Table
CREATE TABLE StudentCourse (
StudentID VARCHAR(10),
CourseID VARCHAR(10),
PRIMARY KEY (StudentID, CourseID),
FOREIGN KEY (StudentID) REFERENCES Students(StudentID),
FOREIGN KEY (CourseID) REFERENCES Courses(CourseID)
);
-- Insert Students
INSERT INTO Students VALUES ('S1', 'Alice');
INSERT INTO Students VALUES ('S2', 'Bob');

-- Insert Instructors
INSERT INTO Instructors VALUES ('I1', 'Prof. Smith');
INSERT INTO Instructors VALUES ('I2', 'Prof. John');
INSERT INTO Instructors VALUES ('I3', 'Prof. Mary');

-- Insert Courses
INSERT INTO Courses VALUES ('C101', 'DBMS', 'I1');
INSERT INTO Courses VALUES ('C102', 'Networks', 'I2');
INSERT INTO Courses VALUES ('C103', 'AI', 'I3');

-- Student-Course Mapping
INSERT INTO StudentCourse VALUES ('S1', 'C101');
INSERT INTO StudentCourse VALUES ('S2', 'C102');
INSERT INTO StudentCourse VALUES ('S1', 'C103');

Query with JOINs
Now, let’s list all students with their courses and instructors:

SELECT s.StudentName, c.CourseName, i.InstructorName
FROM Students s
JOIN StudentCourse sc ON s.StudentID = sc.StudentID
JOIN Courses c ON sc.CourseID = c.CourseID
JOIN Instructors i ON c.InstructorID = i.InstructorID;

THANK YOU @santhoshnc sir for guiding and supporting me!!

College Student & Course Management System

Boopathy.S — Thu, 21 Aug 2025 14:33:06 +0000

INTRODUCTION:
In this blog we are going to create a college student and course management system .Managing students, courses, and enrollments is a common requirement in colleges and universities. In this blog, we’ll build a Student and Course Management System step by step using Oracle SQL.

we will learn how to:

Create relational tables (Students, Courses, and Enrollments)

Insert sample data

Alter tables and add constraints

Run queries to retrieve meaningful results

Step 1: Create the Students table
We’ll start by creating a Students table to store student information.

sql
CREATE TABLE Students (
StudentID NUMBER PRIMARY KEY,
Name VARCHAR2(50) NOT NULL,
Dept VARCHAR2(30),
DOB DATE,
Email VARCHAR2(50) UNIQUE
);
Explanation:
StudentID: Primary key, ensures uniqueness.
Name: Student name (mandatory field).
Dept: Department of the student.
DOB: Date of Birth.
Email: Must be unique for every student.

Step 2: Create the Courses table
Now, let’s create a table to store various courses.
sql
CREATE TABLE Courses (
CourseID NUMBER PRIMARY KEY,
CourseName VARCHAR2(50) NOT NULL,
Credits NUMBER(2)
);
We also want to make sure credits are valid. Let’s add a constraint:
sql
ALTER TABLE Courses ADD CHECK (Credits BETWEEN 1 AND 5);

Step 3: Create the Enrollments table
The Enrollments table connects students and courses.

sql
CREATE TABLE Enrollments (
EnrollID NUMBER PRIMARY KEY,
StudentID NUMBER REFERENCES Students(StudentID),
CourseID NUMBER REFERENCES Courses(CourseID),
Grade CHAR(2)
);
This establishes foreign key relationships, ensuring only valid students and valid courses can be enrolled.

Step 4: Insert Sample Data
Insert a few students:
sql
INSERT INTO Students (StudentID, Name, Dept, DOB, Email)
VALUES (1, 'JAI', 'Computer Science', TO_DATE('2006-03-15', 'YYYY-MM-DD'), 'jai.cs@example.com');

INSERT INTO Students (StudentID, Name, Dept, DOB, Email)
VALUES (2, 'MATHI', 'Electrical Engineering', TO_DATE('2006-11-22', 'YYYY-MM-DD'), 'mathi.ee@example.com');

INSERT INTO Students (StudentID, Name, Dept, DOB, Email)
VALUES (3, 'PRIAN', 'Mechanical Engineering', TO_DATE('2006-07-09', 'YYYY-MM-DD'), 'prian.mech@example.com');
Insert courses:

sql
INSERT INTO Courses (CourseID, CourseName, Credits)
VALUES (101, 'Database Systems', 3);

INSERT INTO Courses (CourseID, CourseName, Credits)
VALUES (102, 'Operating Systems', 4);

INSERT INTO Courses (CourseID, CourseName, Credits)
VALUES (103, 'Data Structures', 5);
Don’t forget to commit your changes:

sql
COMMIT;

Step 5: Alter Table (Add Phone Number)
Let’s add a new column for student phone numbers:

sql
ALTER TABLE Students ADD PhoneNo VARCHAR2(10);

Step 6: Run Useful Queries

Display student names in uppercase with email length sql SELECT UPPER(Name) AS Student_Name, LENGTH(Email) AS Email_Length FROM Students;
Show all courses with credits sql SELECT CourseID, CourseName, Credits FROM Courses;
Display all students sql SELECT StudentID, Name, Dept, DOB, Email, PhoneNo FROM Students;

Finally:
We have successfully built a College Student and Course Management System using Oracle SQL.

Thank You @santhoshnc sir for guiding me.