DEV Community: Divya _Sundarasekaran

AWS Service: Amazon DynamoDB

Divya _Sundarasekaran — Thu, 18 Dec 2025 16:59:32 +0000

Amazon DynamoDB

*Service Overview
*
Amazon DynamoDB is a fully managed NoSQL database service that provides fast and predictable performance with seamless scalability. It is designed for applications that need consistent, single-digit millisecond latency at any scale. DynamoDB handles the administrative burdens of operating and scaling a distributed database, so developers can focus on building applications.

Key Features

Managed NoSQL Database: Fully managed, serverless, and scalable.

High Performance: Consistent single-digit millisecond latency.

Automatic Scaling: Scales throughput and storage automatically based on application needs.

Global Tables: Multi-region, fully replicated tables for high availability and disaster recovery.

Integrated Security: Supports AWS IAM for fine-grained access control, encryption at rest, and TLS for data in transit.

Streams & Triggers: Supports DynamoDB Streams to capture changes and integrate with AWS Lambda for event-driven architectures.

Backup and Restore: On-demand and continuous backups for data protection.

AWS Category / Cloud Domain

Category: Database / NoSQL

Cloud Domain: Data Storage, Serverless Databases

Where It Fits in Cloud / DevOps Lifecycle

Application Layer: Used as the primary database for web, mobile, IoT, and gaming applications.

DevOps Integration: Can be provisioned via Infrastructure as Code (IaC) tools like AWS CloudFormation or Terraform; integrates with CI/CD pipelines for automated deployments.

Event-Driven Workflows: Works seamlessly with AWS Lambda, API Gateway, and other services for serverless architectures.

Programming Language / Access Methods

APIs / SDKs: Available for Python (boto3), Java, JavaScript (Node.js), .NET, Go, Ruby, PHP, and C++.

Access Methods:

AWS Management Console

AWS CLI

AWS SDKs

REST API

Pricing Model

On-Demand Capacity Mode: Pay-per-request for read and write operations.

Provisioned Capacity Mode: Predefine read/write capacity units; can scale manually or with auto-scaling.

Storage Costs: Charged per GB-month of data stored.

Optional Features: Additional costs for backups, streams, global tables, and data transfer. THANK YOU @santhoshnc sir!!

DevSecOps Periodic Table

Divya _Sundarasekaran — Thu, 18 Dec 2025 16:42:54 +0000

Digital.ai Intelligence in the DevSecOps Periodic Table

In modern DevOps and DevSecOps environments, teams generate huge amounts of data from planning, build, security, testing, release, deployment, and operations tools. Without proper intelligence, this data often remains siloed and difficult to interpret.

Digital.ai Intelligence is an AI-powered analytics and intelligence platform that helps organizations transform raw SDLC data into actionable insights.

Overview of Digital.ai Intelligence

Digital.ai Intelligence unifies data from multiple sources, correlates it using AI/ML, and presents predictive and actionable insights to help teams improve delivery performance, reduce risk, and make better business decisions.
It centralizes information from Digital.ai solutions and third-party tools, offering dashboards, predictive analytics, and KPIs tailored to DevOps and DevSecOps workflows.

Key Features

AI-Powered Analytics
Automatically analyzes and correlates data from multiple DevOps tools to identify bottlenecks and trends.

Predictive Insights
Uses machine learning to forecast delivery risks, potential failures, and improvement opportunities.

Flow & DORA Metrics
Provides pre-built dashboards for Flow metrics, DORA metrics, and customizable KPIs to track performance across teams and portfolios.

Customizable Dashboards
Teams can define their own metrics, dashboards, and KPIs according to organizational needs.

Enterprise Visibility
Supports role-based views from individual contributors to executives, providing consistent insights into delivery and security.

Seamless Integrations
Integrates with popular tools like Jira, Git, Jenkins, ServiceNow, and other monitoring/security solutions.

*How Digital.ai Intelligence Fits into DevOps & DevSecOps
*
In DevOps:

Improves visibility into delivery pipelines

Helps detect bottlenecks and improve cycle times

Provides predictive insights to reduce rework

In DevSecOps:

Correlates security, quality, and delivery signals

Detects risky changes and potential vulnerabilities early

Supports collaboration between Dev, Sec, and Ops teams

Digital.ai Intelligence ensures continuous improvement and risk-aware software delivery, perfectly aligning with DevSecOps principles.

Programming Languages & Technology

Core platform likely uses Python and Java for analytics and AI

JavaScript/TypeScript for dashboards and UI

SQL/NoSQL for data modeling and storage

Cloud-native, scalable architecture with APIs for integration and automation.

Parent Company

Company Name: Digital.ai

Focus: AI-powered DevOps and DevSecOps platform

Headquarters: United States

Type: Private company

Digital.ai delivers enterprise-scale solutions for planning, security, testing, release orchestration, deployment, and predictive analytics.

Open Source or Paid?

Not Open Source

Paid / Commercial SaaS Product
Digital.ai Intelligence is a proprietary, enterprise-grade platform available through subscription or enterprise licensing.THANK YOU @santhoshnc sir!!

Simple College Student Schema in MongoDB

Divya _Sundarasekaran — Fri, 03 Oct 2025 06:01:05 +0000

Simple College Student Schema in MongoDB

Introduction

MongoDB is a popular NoSQL database that stores data in flexible JSON-like documents, making it easy to work with real-world data. Unlike traditional relational databases, MongoDB doesn’t require fixed table schemas, which is perfect for modern applications.

In this blog, we’ll explore CRUD operations (Create, Read, Update, Delete) using a college student database. You’ll learn how to insert student records, query them, update information, and delete records efficiently.

All examples are demonstrated on a MongoDB Atlas Cluster, so you can follow along with screenshots and see results live.

What You’ll Learn:

How to insert multiple student records into a collection

How to query records with conditions

How to update single and multiple documents

How to delete records selectively

How CRUD applies in real-world projects

Step 1: Setup MongoDB Cluster

Create a cluster and a database called collegeDB.

Inside the database, create a collection named students.

Step 2: Insert Student Records

We’ll add 5 student records using insertMany:

db.students.insertMany([
{ "student_id": "S001", "name": "Santhosh", "age": 20, "department": "CSBS", "year": 2, "cgpa": 9 },
{ "student_id": "S002", "name": "Aishwarya", "age": 21, "department": "CSE", "year": 3, "cgpa": 8.5 },
{ "student_id": "S003", "name": "Rahul", "age": 22, "department": "IT", "year": 3, "cgpa": 7.8 },
{ "student_id": "S004", "name": "Priya", "age": 20, "department": "CSBS", "year": 1, "cgpa": 9.2 },
{ "student_id": "S005", "name": "Karthik", "age": 23, "department": "CSE", "year": 4, "cgpa": 6.9 }
])

Step 3: Read (Query) Data

Display all student records:

db.students.find()

Find students with CGPA > 8:

db.students.find({ cgpa: { $gt: 8 } })

Find students in the Computer Science department:

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

Step 4: Update Records

Update the CGPA of a specific student (S005):

db.students.updateOne(
{ student_id: "S005" },
{ $set: { cgpa: 7.5 } }
)

Increase the year of all 3rd-year students by 1:

db.students.updateMany(
{ year: 3 },
{ $inc: { year: 1 } }
)

Step 5: Delete Records

Delete a student by student_id:

db.students.deleteOne({ student_id: "S005" }

Conclusion

In this tutorial, we’ve covered CRUD operations in MongoDB using a student database example.

From inserting records, querying, updating, to deleting data, these operations form the foundation of almost every modern application.

This hands-on approach helps you understand NoSQL database workflows and prepares you for real-world projects like user management systems, e-commerce apps, or academic databases.

Indexing, Hashing & Query Optimization

Divya _Sundarasekaran — Thu, 02 Oct 2025 15:44:29 +0000

Indexing, Hashing & Query Optimization in SQL

When working with large datasets, searching for data efficiently is crucial. Indexing and Hashing help databases retrieve data faster, improving performance for queries.

In this post, we’ll demonstrate B-Tree, B+ Tree, and Hash indexes using a Students table.

Create Database and Students Table
CREATE DATABASE college;
USE college;

CREATE TABLE Students (
roll_no INT PRIMARY KEY,
name VARCHAR(50),
dept VARCHAR(20),
cgpa DECIMAL(3,2)
);

Insert Sample Records
INSERT INTO Students VALUES
(101, 'Alice', 'CSBS', 9.1),
(102, 'Bob', 'ECE', 7.5),
(103, 'Charlie', 'MECH', 8.2),
(104, 'David', 'CIVIL', 6.9),
(105, 'Emma', 'CSBS', 8.7),
(106, 'Frank', 'IT', 7.8),
(107, 'Grace', 'ECE', 8.5),
(108, 'Helen', 'MECH', 7.2),
(109, 'Ivy', 'CIVIL', 8.9),
(110, 'Jack', 'CSBS', 9.3),
(111, 'Karan', 'IT', 6.8),
(112, 'Leo', 'ECE', 8.0),
(113, 'Mia', 'MECH', 7.9),
(114, 'Nina', 'CSBS', 9.0),
(115, 'Owen', 'CIVIL', 8.3),
(116, 'Paul', 'IT', 7.4),
(117, 'Queen', 'ECE', 8.6),
(118, 'Ravi', 'CSBS', 8.8),
(119, 'Sophia', 'MECH', 7.6),
(120, 'Tom', 'CIVIL', 8.1);

B-Tree Index on roll_no
CREATE INDEX idx_rollno_btree
ON Students(roll_no);

SELECT * FROM Students
WHERE roll_no = 110;

B-Tree indexes are ideal for equality and range queries.

B+ Tree Index on cgpa
CREATE INDEX idx_cgpa_bplustree
ON Students(cgpa);

SELECT * FROM Students
WHERE cgpa > 8.0;

✔ B+ Tree indexes are optimized for range queries, making it fast to find all students with CGPA above 8.0.

Hash Index on dept
CREATE INDEX idx_dept_hash
ON Students(dept) USING HASH;

SELECT * FROM Students
WHERE dept = 'CSBS';

Hash indexes are perfect for equality lookups, such as fetching all students from a specific department.

Summary

B-Tree Index (roll_no) → Fast equality and range queries.

B+ Tree Index (cgpa) → Efficient for range queries (cgpa > 8.0).

Hash Index (dept) → Best for exact-match queries (dept = 'CSBS').

Indexes improve query performance significantly, especially when datasets are large. Using the right type of index based on your query patterns is key to database optimization.

Transactions, Deadlocks & Log-Based Recovery

Divya _Sundarasekaran — Thu, 02 Oct 2025 07:50:08 +0000

Transactions, Deadlocks & Log-Based Recovery in SQL

In this tutorial, we’ll explore transactions, deadlocks, and log-based recovery in SQL using a simple BankAccounts table. These are key concepts in database management for ensuring data consistency, integrity, and recoverability.

Schema Setup
CREATE DATABASE BankDB;

USE BankDB;

CREATE TABLE BankAccounts (
acc_no INT PRIMARY KEY,
name VARCHAR(50),
balance INT
);

INSERT INTO BankAccounts VALUES
(1, 'Alice', 1000),
(2, 'Bob', 1500),
(3, 'Charlie', 2000);

SELECT * FROM BankAccounts;

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

Transaction – Atomicity & Rollback
BEGIN;

UPDATE BankAccounts
SET balance = balance - 500
WHERE name = 'Alice';

UPDATE BankAccounts
SET balance = balance + 500
WHERE name = 'Bob';

ROLLBACK;

SELECT * FROM BankAccounts;

Expected Result:
Balances remain unchanged:

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

Deadlock Simulation

Deadlocks occur when two transactions wait for each other’s locks indefinitely. No SELECT queries are needed; updates are enough.

Session 1:

BEGIN;
UPDATE BankAccounts SET balance = balance + 100 WHERE name='Alice';

Session 2:

BEGIN;
UPDATE BankAccounts SET balance = balance + 200 WHERE name='Bob';

Then each session tries to update the other’s row:

Session 1:

UPDATE BankAccounts SET balance = balance - 50 WHERE name='Bob';

Session 2:

UPDATE BankAccounts SET balance = balance - 50 WHERE name='Alice';

At this point, both sessions wait for the other’s lock → deadlock occurs, and the database will abort one transaction.

Tip: Always acquire locks in the same order to prevent deadlocks.

Log-Based Recovery

Databases maintain transaction logs to recover from failures. Even if a transaction is rolled back, the log records the operations and their undo.

BEGIN;
UPDATE BankAccounts SET balance = balance + 500 WHERE name='Charlie';
ROLLBACK;

SELECT * FROM BankAccounts;

Result:

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

The rollback undid the changes. Internally, the database logs contain both the attempted update and its undo operation.

Conclusion

Atomicity: Ensures transactions are all-or-nothing.

Deadlocks: Can occur in concurrent transactions; careful lock ordering prevents them.

Log-Based Recovery: Guarantees durability and consistency even after rollbacks or crashes.

ACID Properties

Divya _Sundarasekaran — Thu, 02 Oct 2025 06:15:24 +0000

Demonstrating ACID Properties in MySQL with Accounts Table

In this blog, we’ll explore the ACID properties—Atomicity, Consistency, Isolation, and Durability—using a simple Accounts table in MySQL.

Setting Up the Table

We start by creating a database and the Accounts table with three sample records.

CREATE DATABASE IF NOT EXISTS BankDB;
USE BankDB;

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

INSERT INTO Accounts (acc_no, name, balance) VALUES
(101, 'Alice', 5000),
(102, 'Bob', 3000),
(103, 'Charlie', 7000);

SELECT * FROM Accounts;

Atomicity

Atomicity ensures that a transaction is all or nothing. Let’s transfer money between accounts:

USE BankDB;

BEGIN;

UPDATE Accounts
SET balance = balance - 1000
WHERE acc_no = 101;

UPDATE Accounts
SET balance = balance + 1000
WHERE acc_no = 102;

SELECT * FROM Accounts;

Consistency

Consistency ensures that invalid data cannot be inserted. We enforce a rule that balance cannot be negative.

USE BankDB;

ALTER TABLE Accounts
ADD CONSTRAINT chk_balance CHECK (balance >= 0);

INSERT INTO Accounts (acc_no, name, balance) VALUES (104, 'David', -500);

Observation:

MySQL rejects the insert because it violates the constraint:

ERROR 3819 (HY000): Check constraint 'chk_balance' is violated.

Isolation

Isolation ensures that concurrent transactions do not interfere with each other.

Session 1 – Updating:

USE BankDB;

BEGIN;

UPDATE Accounts
SET balance = balance + 500
WHERE acc_no = 101;

Session 2 – Reading concurrently:

USE BankDB;

SELECT * FROM Accounts WHERE acc_no = 101;

Observation:

Session 2 cannot see uncommitted changes from Session 1.

After committing Session 1, Session 2 will see the updated balance.

Durability

Durability ensures that committed data persists even after a crash or restart.

USE BankDB;

BEGIN;

UPDATE Accounts
SET balance = balance + 200
WHERE acc_no = 102;

COMMIT;

SELECT * FROM Accounts;

Observation:

After committing and restarting the database, the updated balance remains.

Conclusion

We have successfully demonstrated all ACID properties in MySQL using the Accounts table:

Atomicity: Transactions are all-or-nothing.

Consistency: Database rules prevent invalid data.

Isolation: Concurrent transactions do not interfere.

Durability: Committed data persists.

Deliverables: SQL scripts and screenshots are included above for reference.

Cursor and Trigger

Divya _Sundarasekaran — Thu, 02 Oct 2025 05:39:55 +0000

Cursor: Display Employees with Salary > 50,000

A cursor allows you to go row by row through a query result. Here, we will display employee names whose salary is greater than 50,000.

CREATE DATABASE school;
USE school;

CREATE TABLE Employee (
EmpID INT PRIMARY KEY,
EmpName VARCHAR(50),
Salary DECIMAL(10,2)
);

INSERT INTO Employee VALUES (1, 'Alice', 60000);
INSERT INTO Employee VALUES (2, 'Bob', 45000);
INSERT INTO Employee VALUES (3, 'Charlie', 70000);

DELIMITER $$

CREATE PROCEDURE EmployeeCursorProc()
BEGIN
DECLARE done INT DEFAULT 0;
DECLARE emp_name VARCHAR(50);
DECLARE cur CURSOR FOR SELECT EmpName FROM Employee WHERE Salary > 50000;
DECLARE CONTINUE HANDLER FOR NOT FOUND SET done = 1;

OPEN cur;

read_loop: LOOP
    FETCH cur INTO emp_name;
    IF done THEN
        LEAVE read_loop;
    END IF;
    SELECT emp_name;
END LOOP;

CLOSE cur;

END$$

DELIMITER ;

CALL EmployeeCursorProc();

Trigger: AFTER INSERT on Students Table

A trigger automatically executes an action when a specific event happens in the database. Here, we will log student registrations.

CREATE TABLE Students (
StudentID INT PRIMARY KEY,
StudentName VARCHAR(50),
Course VARCHAR(50)
);

CREATE TABLE Student_Audit (
AuditID INT AUTO_INCREMENT PRIMARY KEY,
StudentID INT,
Action VARCHAR(50),
ActionDate DATETIME
);

DELIMITER $$

CREATE TRIGGER trg_Student_Insert
AFTER INSERT ON Students
FOR EACH ROW
BEGIN
INSERT INTO Student_Audit (StudentID, Action, ActionDate)
VALUES (NEW.StudentID, 'Inserted', NOW());
END$$

DELIMITER ;

INSERT INTO Students (StudentID, StudentName, Course)
VALUES (1, 'John Doe', 'Mathematics');

SELECT * FROM Student_Audit;

Summary:

Cursors let you process each row of a query result individually. In this example, it helps display only employees with salary above 50,000.

Triggers automate database tasks. Here, the AFTER INSERT trigger automatically logs student registrations into Student_Audit without manual effort.

Using cursors and triggers together helps maintain data integrity and reduces repetitive work in a database.

Cursor and Trigger

Divya _Sundarasekaran — Thu, 02 Oct 2025 05:34:34 +0000

Cursor: Display Employees with Salary > 50,000

A cursor allows you to go row by row through a query result. Here, we will display employee names whose salary is greater than 50,000.

CREATE DATABASE school;
USE school;

CREATE TABLE Employee (
EmpID INT PRIMARY KEY,
EmpName VARCHAR(50),
Salary DECIMAL(10,2)
);

INSERT INTO Employee VALUES (1, 'Alice', 60000);
INSERT INTO Employee VALUES (2, 'Bob', 45000);
INSERT INTO Employee VALUES (3, 'Charlie', 70000);

DELIMITER $$

OPEN cur;

read_loop: LOOP
    FETCH cur INTO emp_name;
    IF done THEN
        LEAVE read_loop;
    END IF;
    SELECT emp_name;
END LOOP;

CLOSE cur;

END$$

DELIMITER ;

CALL EmployeeCursorProc();

Trigger: AFTER INSERT on Students Table

A trigger automatically executes an action when a specific event happens in the database. Here, we will log student registrations.

CREATE TABLE Students (
StudentID INT PRIMARY KEY,
StudentName VARCHAR(50),
Course VARCHAR(50)
);

CREATE TABLE Student_Audit (
AuditID INT AUTO_INCREMENT PRIMARY KEY,
StudentID INT,
Action VARCHAR(50),
ActionDate DATETIME
);

DELIMITER $$

CREATE TRIGGER trg_Student_Insert
AFTER INSERT ON Students
FOR EACH ROW
BEGIN
INSERT INTO Student_Audit (StudentID, Action, ActionDate)
VALUES (NEW.StudentID, 'Inserted', NOW());
END$$

DELIMITER ;

INSERT INTO Students (StudentID, StudentName, Course)
VALUES (1, 'John Doe', 'Mathematics');

SELECT * FROM Student_Audit;

Summary:

Cursors let you process each row of a query result individually. In this example, it helps display only employees with salary above 50,000.

Triggers automate database tasks. Here, the AFTER INSERT trigger automatically logs student registrations into Student_Audit without manual effort.

Using cursors and triggers together helps maintain data integrity and reduces repetitive work in a database.

Normalization

Divya _Sundarasekaran — Thu, 02 Oct 2025 05:05:55 +0000

Database Normalization in SQL – From 1NF to 3NF
Introduction:

In this blog, we will explore Database Normalization with a practical SQL example. We’ll start with an unnormalized student-course table, identify anomalies, and then normalize the table step by step into 1NF, 2NF, and 3NF. Finally, we’ll use SQL JOIN queries to retrieve meaningful information.

Step 1: Data Anomalies in Unnormalized Tables

When data is not properly organized, we face:

Insertion Anomaly – Can’t add a course without assigning it to a student.

Update Anomaly – Updating instructor details in multiple rows creates redundancy.

Deletion Anomaly – Deleting a student might accidentally remove course information too.

Step 2: First Normal Form (1NF)

In 1NF, data must be atomic, with no repeating groups.

CREATE TABLE StudentCourse_1NF (
StudentName VARCHAR(50),
CourseID VARCHAR(10),
CourseName VARCHAR(50),
Instructor VARCHAR(50),
InstructorPhone VARCHAR(15)
);

Step 3: Second Normal Form (2NF)

In 2NF, we remove partial dependencies. We separate students and courses.

Tables created:

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

CREATE TABLE StudentCourse_2NF (
StudentName VARCHAR(50),
CourseID VARCHAR(10),
FOREIGN KEY (CourseID) REFERENCES Course_2NF(CourseID)
);

Step 4: Third Normal Form (3NF)

In 3NF, we remove transitive dependencies. Instructor details are moved into a new table.

Tables created:

CREATE TABLE Instructor_3NF (
Instructor VARCHAR(50) PRIMARY KEY,
InstructorPhone VARCHAR(15)
);

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

CREATE TABLE StudentCourse_3NF (
StudentName VARCHAR(50),
CourseID VARCHAR(10),
FOREIGN KEY (CourseID) REFERENCES Course_3NF(CourseID)
);

Step 5: Inserting Data

We then inserted sample data into the normalized tables using INSERT INTO.

Step 6: JOIN Query

Finally, we retrieved the data using JOINs to display students with their courses and instructors:

SELECT s.StudentName, c.CourseName, i.Instructor
FROM StudentCourse_3NF s
JOIN Course_3NF c ON s.CourseID = c.CourseID
JOIN Instructor_3NF i ON c.Instructor = i.Instructor;

Conclusion

We successfully normalized a student-course table from 1NF → 2NF → 3NF. Along the way, we eliminated redundancy, avoided data anomalies, and ensured data integrity.

With proper JOINs, we could easily retrieve clean and consistent information from the database.

Normalization ensures our databases are efficient, reliable, and scalable.

COLLEGE STUDENT & COURSE MANAGEMENT SYSTEM.

Divya _Sundarasekaran — Fri, 22 Aug 2025 13:36:14 +0000

In this blog we are going to creating tables, inserting data, and running some useful queries with Oracle SQL.

Step 1: Create the Students Table
We’ll start by creating a table for students. This table holds student details along with a unique email ID.

sql
CREATE TABLE Students (
StudentID NUMBER PRIMARY KEY,
Name VARCHAR2(50) NOT NULL,
Dept VARCHAR2(30),
DOB DATE,
Email VARCHAR2(50) UNIQUE
);

StudentID is the primary key (unique for each student).

Email must be unique.

We’ll add phone numbers later.

Step 2: Create the Courses Table
Next, we build a table for courses:

sql
CREATE TABLE Courses (
CourseID NUMBER PRIMARY KEY,
CourseName VARCHAR2(50) NOT NULL,
Credits NUMBER(2)
);

Credits will later have a constraint (between 1 and 5).

Step 3: Create the Enrollments Table
Since students can enroll in multiple courses, we need a join table:

sql
CREATE TABLE Enrollments (
EnrollID NUMBER PRIMARY KEY,
StudentID NUMBER REFERENCES Students(StudentID),
CourseID NUMBER REFERENCES Courses(CourseID),
Grade CHAR(2)
);
Here:
Enrollments connects StudentID ↔ CourseID.

We can also store the student’s grade.

Step 4: Insert Sample Data
Let’s add a few student records:

sql
INSERT INTO Students (StudentID, Name, Dept, DOB, Email)
VALUES (2, 'DIVYA','AIDS', TO_DATE('11/22/2007', 'MM/DD/YYYY'), 'divya12ad@gmail.com');

INSERT INTO Students (StudentID, Name, Dept, DOB, Email)
VALUES (3, 'DIKSHA', 'IT', TO_DATE('7/9/2008', 'MM/DD/YYYY'), 'diksha11it@gmail.com');

INSERT INTO Students (StudentID, Name, Dept, DOB, Email)
VALUES (1, 'HARINI', 'Computer Science', TO_DATE('3/15/2007', 'MM/DD/YYYY'), 'harini16cs@gmail.com');

Step 5: Altering the Table (Adding Columns + Constraints)
Suppose we forgot to add phone numbers. Let’s fix that:

sql
ALTER TABLE Students
ADD PhoneNo VARCHAR2(10);
Also, ensure course credits are between 1 and 5:

sql
ALTER TABLE Courses
ADD CHECK (Credits BETWEEN 1 AND 5);

Step 6: Insert Courses
sql
INSERT INTO Courses (CourseID, CourseName, Credits)
VALUES (101, 'MACHINE LEARNING', 3);

INSERT INTO Courses (CourseID, CourseName, Credits)
VALUES (102, 'OPERATING SYSTEMS', 4);

INSERT INTO Courses (CourseID, CourseName, Credits)
VALUES (103, 'Data Structures', 5);

Step 7: Committing Data
Always save your changes:

sql
COMMIT;

Step 8: Querying the Database
Now, let’s run some useful queries:

Show student names in uppercase & length of their email address:

sql
SELECT
UPPER(Name) AS Student_Name,
LENGTH(Email) AS Email_Length
FROM Students;
Check available courses:

sql
SELECT CourseID, CourseName, Credits
FROM Courses;
View all student details:

sql
SELECT StudentID, Name, Dept, DOB, Email, PhoneNo
FROM Students;

we have created a database which includes the insertion of data,altering
and showing the output.

THANK YOU SIR @santhoshnc for supporting and guiding me.