DEV Community: BHARANIKA D 24CB005

AWS Services

BHARANIKA D 24CB005 — Thu, 18 Dec 2025 17:04:39 +0000

AWS Databases (Category)
🔍 Service Overview
AWS Databases is a collection of fully managed database services provided by AWS.
It supports relational, NoSQL, in-memory, graph, time-series, ledger, and data warehouse databases.

👉 AWS handles infrastructure, scaling, backups, patching, and high availability.

✨ Key Features
🔹 Fully managed database services
🔹 Automatic backups & point-in-time recovery
🔹 High availability & Multi-AZ support
🔹 Horizontal & vertical scalability
🔹 Encryption at rest & in transit
🔹 Integration with IAM, VPC, CloudWatch
🔹 Pay-as-you-go pricing

🗂️ AWS Category / Cloud Domain
Category: Database
Cloud Domain: Data Management / Storage

🔹 Major Services under AWS Databases:
Amazon RDS – Relational databases

Amazon Aurora – High-performance relational DB

Amazon DynamoDB – NoSQL key-value DB

Amazon ElastiCache – In-memory cache

Amazon Redshift – Data warehouse

Amazon Neptune – Graph database

Amazon Timestream – Time-series database

Amazon QLDB – Ledger database

🔄 Where It Fits in Cloud / DevOps Lifecycle
📌 Application Development – Store app data
📌 CI/CD Pipelines – Backend data persistence
📌 DevOps – Automated scaling & monitoring
📌 DevSecOps – Secure data with IAM & encryption
📌 Production & Operations – High availability & backups

👉 Used mainly in Build → Deploy → Operate → Monitor stages.

💻Programming Languages / Access Methods

AWS Databases can be accessed using:

🔹 Programming Languages

Java

Python

Node.js

.NET

PHP

🔹 Access Methods

AWS SDKs

AWS CLI

AWS Management Console

JDBC / ODBC

REST APIs

💰 Pricing Model

💵 Pay-as-you-go

Pricing depends on:

Instance type

Storage used

Read/Write capacity

Data transfer

Backup storage

⚠️ No upfront cost
⚠️ Free Tier available (limited)

DevSecOps Periodic Table...

BHARANIKA D 24CB005 — Thu, 18 Dec 2025 15:44:29 +0000

🚀 Backstage
(Bg) – DevSecOps Tool

🧩 Overview
🔆Backstage is an open-source developer portal.
🔆It helps developers manage all services, tools, documentation, and APIs in one place.
🔆It is very useful for organizations that use many microservices, as it reduces confusion and improves visibility.

✨ Key Features
🔹Centralized Developer Portal – All services and tools in one dashboard

🔹 Service Catalog – List of backend services, frontend apps, and APIs

🔹 Software Templates – Quickly create new projects

🔹 Tech Docs Support – Documentation using Markdown

🔹 Plugin Support – Integrates with Jenkins, Kubernetes, GitHub, AWS, etc.

🔹 Role-Based Access Control – Access based on team or role

🔐DevOps / DevSecOps Fit
Backstage improves developer productivity in DevOps.

In DevSecOps, it helps by:

🔐 Integrating security tools

🔐 Maintaining secure coding standards and documentation

🔐 Providing visibility into CI/CD pipelines

🔐 Improving compliance and service ownership

👉 It allows security, development, and operations to be managed from a single platform.

💻 Programming Languages

TypeScript

JavaScript (Node.js)

React (Frontend)

🏢 Parent Company
🎧Spotify

Backstage was originally developed by Spotify engineers.

Open Source or Paid?
📜 Licensed under Apache 2.0

✅ Open Source

🆓 Free to use, extend, and customize

🚀 Understanding Indexing in Oracle (B-Tree, B+ Tree, Hash Cluster) Indexes are one of the most important concepts in databases.

BHARANIKA D 24CB005 — Sat, 01 Nov 2025 10:59:25 +0000

🚀 Understanding Indexing in Oracle (B-Tree, B+ Tree, Hash Cluster) Indexes are one of the most important concepts in databases. They speed up queries, reduce table scans, and optimize performance. In this post, we’ll explore B-Tree, B+ Tree, and Hash Indexing (via Hash Cluster) in Oracle using Students table.

📌 Step 1: Create the Students Table

CREATE TABLE Students (
    roll_no INT PRIMARY KEY,
    name VARCHAR2(50),
    dept VARCHAR2(10),
    cgpa NUMBER(3,2)
);

📌 Step 2: Insert 20 Sample Records

INSERT INTO Students VALUES (101, 'Alice', 'CSBS', 9.1);
INSERT INTO Students VALUES (102, 'Bob', 'IT', 7.5);
INSERT INTO Students VALUES (103, 'Charlie', 'CSE', 8.6);
INSERT INTO Students VALUES (104, 'David', 'ECE', 7.9);
INSERT INTO Students VALUES (105, 'Eva', 'CSBS', 8.3);
INSERT INTO Students VALUES (106, 'Frank', 'MECH', 6.5);
INSERT INTO Students VALUES (107, 'Grace', 'EEE', 8.8);
INSERT INTO Students VALUES (108, 'Helen', 'CIVIL', 7.0);
INSERT INTO Students VALUES (109, 'Ivy', 'CSE', 8.9);
INSERT INTO Students VALUES (110, 'Jack', 'CSBS', 9.0);
INSERT INTO Students VALUES (111, 'Karan', 'IT', 7.8);
INSERT INTO Students VALUES (112, 'Leo', 'CSE', 8.1);
INSERT INTO Students VALUES (113, 'Maya', 'ECE', 8.5);
INSERT INTO Students VALUES (114, 'Nina', 'MECH', 6.8);
INSERT INTO Students VALUES (115, 'Oscar', 'EEE', 8.7);
INSERT INTO Students VALUES (116, 'Paul', 'CIVIL', 7.2);
INSERT INTO Students VALUES (117, 'Queen', 'CSBS', 9.3);
INSERT INTO Students VALUES (118, 'Raj', 'CSE', 8.0);
INSERT INTO Students VALUES (119, 'Sara', 'IT', 7.6);
INSERT INTO Students VALUES (120, 'Tom', 'CSBS', 9.2);

📌 Step 3: B-Tree Index (on Roll Number)

Oracle’s default index type is a B-Tree index.

CREATE INDEX idx_rollno ON Students(roll_no);

Now query with the index:

SELECT * FROM Students WHERE roll_no = 110;

📌 Step 4: B+ Tree Index (on CGPA)

B+ Trees are used internally by Oracle when you create a normal index on numeric columns.

CREATE INDEX idx_cgpa ON Students(cgpa);

SELECT * FROM Students WHERE cgpa > 8.0;

📌 Step 5: Hash Index via Hash Cluster (on Department)
Oracle does not allow USING HASH in CREATE INDEX.
Instead, we use a Hash Cluster.

CREATE CLUSTER student_cluster (dept VARCHAR2(10))
SIZE 512
HASHKEYS 20;

CREATE TABLE Students_Hash (
    roll_no INT PRIMARY KEY,
    name VARCHAR2(50),
    dept VARCHAR2(10),
    cgpa NUMBER(3,2)
) CLUSTER student_cluster(dept);

INSERT INTO Students_Hash VALUES (101, 'Alice', 'CSBS', 9.1);
INSERT INTO Students_Hash VALUES (102, 'Bob', 'IT', 7.5);
INSERT INTO Students_Hash VALUES (103, 'Charlie', 'CSE', 8.6);
INSERT INTO Students_Hash VALUES (104, 'David', 'ECE', 7.9);
INSERT INTO Students_Hash VALUES (105, 'Eva', 'CSBS', 8.3);
INSERT INTO Students_Hash VALUES (106, 'Frank', 'MECH', 6.5);
INSERT INTO Students_Hash VALUES (107, 'Grace', 'EEE', 8.8);
INSERT INTO Students_Hash VALUES (108, 'Helen', 'CIVIL', 7.0);
INSERT INTO Students_Hash VALUES (109, 'Ivy', 'CSE', 8.9);
INSERT INTO Students_Hash VALUES (110, 'Jack', 'CSBS', 9.0);
INSERT INTO Students_Hash VALUES (111, 'Karan', 'IT', 7.8);
INSERT INTO Students_Hash VALUES (112, 'Leo', 'CSE', 8.1);
INSERT INTO Students_Hash VALUES (113, 'Maya', 'ECE', 8.5);
INSERT INTO Students_Hash VALUES (114, 'Nina', 'MECH', 6.8);
INSERT INTO Students_Hash VALUES (115, 'Oscar', 'EEE', 8.7);
INSERT INTO Students_Hash VALUES (116, 'Paul', 'CIVIL', 7.2);
INSERT INTO Students_Hash VALUES (117, 'Queen', 'CSBS', 9.3);
INSERT INTO Students_Hash VALUES (118, 'Raj', 'CSE', 8.0);
INSERT INTO Students_Hash VALUES (119, 'Sara', 'IT', 7.6);
INSERT INTO Students_Hash VALUES (120, 'Tom', 'CSBS', 9.2);

Query with Hash Access

SELECT * FROM Students_Hash WHERE dept = 'CSBS';

🔥 Conclusion

B-Tree Index → best for primary keys, unique lookups.
B+ Tree Index → efficient for range queries (e.g., CGPA > 8).
Hash Cluster → simulates Hash Index in Oracle for exact match lookups.

By combining these, you can optimize queries and improve performance in Oracle SQL.

CRUD (Create, Read, Update, Delete) operations in MongoDB using a simple college student schema.

BHARANIKA D 24CB005 — Sat, 01 Nov 2025 10:55:45 +0000

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

🧱 Schema (Collection: students)

Each document follows this structure:

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

⚙️ 1️⃣ CREATE (INSERT)
Insert at least 5 student records into the students collection:

db.students.insertMany([
  {
    "student_id": "S001",
    "name": "Santhosh",
    "age": 20,
    "department": "CSBS",
    "year": 2,
    "cgpa": 9
  },
  {
    "student_id": "S002",
    "name": "Baviya",
    "age": 19,
    "department": "CSE",
    "year": 1,
    "cgpa": 8.7
  },
  {
    "student_id": "S003",
    "name": "Karthik",
    "age": 21,
    "department": "ECE",
    "year": 3,
    "cgpa": 7.2
  },
  {
    "student_id": "S004",
    "name": "Anu",
    "age": 20,
    "department": "CSE",
    "year": 2,
    "cgpa": 9.3
  },
  {
    "student_id": "S005",
    "name": "Ravi",
    "age": 22,
    "department": "MECH",
    "year": 3,
    "cgpa": 6.8
  }
])

🔍 2️⃣ READ (QUERY)

Find all students with CGPA > 8:

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

Find students belonging to the Computer Science department:

db.students.find({ department: { $in: ["CSE", "CSBS"] } }).pretty()

✏️ 3️⃣ UPDATE
(a) Update the CGPA of a specific student

db.students.updateOne(
  { student_id: "S002" },
  { $set: { cgpa: 9.1 } }
)

(b) Increase the year of study for all 3rd-year students by 1

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

🗑️ 4️⃣ DELETE
(a) Delete one student record by student_id:

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

(b) Delete all students having CGPA < 7.5

db.students.deleteMany({ cgpa: { $lt: 7.5 } })

AFTER DELETION:

💾 ACID Properties

BHARANIKA D 24CB005 — Sat, 01 Nov 2025 10:52:40 +0000

💾 Understanding ACID Properties in Databases with SQL Examples In this post, I’ll demonstrate ACID properties — Atomicity, Consistency, Isolation, and Durability — using a simple Accounts table and a few SQL commands.

Let’s dive in 👇

🧾 1. Table Creation

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

🧩 2. Insert Sample Data

INSERT INTO Accounts VALUES (101, 'Baviya', 3000);
INSERT INTO Accounts VALUES (102, 'Karthik', 4000);
INSERT INTO Accounts VALUES (103, 'Anu', 7000);

⚙️ 3. Atomicity Test (All or Nothing)

Goal: Start a transaction to transfer ₹1000 from Baviya to Karthik but rollback midway — no changes should remain.

-- Start Transaction
START TRANSACTION;

-- Subtract 1000 from Baviya
UPDATE Accounts SET balance = balance - 1000 WHERE acc_no = 101;

-- Add 1000 to Karthik
UPDATE Accounts SET balance = balance + 1000 WHERE acc_no = 102;

-- Now ROLLBACK (cancel transaction)
ROLLBACK;

-- Check balances again
SELECT * FROM Accounts;

🧱 4. Consistency Test (Valid State → Valid State)

Goal: Try inserting invalid (negative) balance.

INSERT INTO Accounts VALUES (104, 'InvalidUser', -500);

🔒 5. Isolation Test (One transaction shouldn’t see another’s uncommitted changes)
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;
COMMIT;

💾 6. Durability Test (Data survives restart)

START TRANSACTION;
UPDATE Accounts SET balance = balance + 200 WHERE acc_no = 103;
COMMIT;

SELECT * FROM Accounts WHERE acc_no = 103;

✅ Conclusion

We successfully verified all ACID properties:

Cursor & Trigger

BHARANIKA D 24CB005 — Sat, 01 Nov 2025 10:41:46 +0000

Summary

A quick walkthrough of Oracle Live SQL practice: creating a table, printing output with SERVEROUTPUT, iterating a cursor, and building an AFTER INSERT trigger to log into an audit table, with screenshots and runnable snippets.

What this post covers

Create and seed an Employee table
Use SET SERVEROUTPUT ON for DBMS_OUTPUT in Live SQL
Loop over rows using a cursor and print names to the script output pane
Write a simple auditing trigger for student inserts and verify audit rows ## 1) Create table + sample data

CREATE TABLE Employee (
EmployeeID INT PRIMARY KEY,
Name VARCHAR2(50),
Salary NUMBER(10,2)
);

INSERT INTO Employee VALUES (1, 'Alice', 60000);
INSERT INTO Employee VALUES (2, 'Bob', 45000);
INSERT INTO Employee VALUES (3, 'Charlie', 75000);
INSERT INTO Employee VALUES (4, 'David', 50000);

2) Print output with DBMS_OUTPUT

SET SERVEROUTPUT ON;

DECLARE
v_count NUMBER;
BEGIN
SELECT COUNT(*) INTO v_count FROM Employee;
DBMS_OUTPUT.PUT_LINE('Rows in Employee: ' || v_count);
END;
/

3) Cursor demo: list high earners

SET SERVEROUTPUT ON;

DECLARE
CURSOR c_emp IS
SELECT Name FROM Employee WHERE Salary > 50000 ORDER BY Salary DESC;

v_name Employee.Name%TYPE;
BEGIN
OPEN c_emp;
LOOP
FETCH c_emp INTO v_name;
EXIT WHEN c_emp%NOTFOUND;
DBMS_OUTPUT.PUT_LINE(v_name);
END LOOP;
CLOSE c_emp;
END;
/

4) Build a simple audit trigger

-- Base tables
CREATE TABLE Students (
StudentID NUMBER PRIMARY KEY,
Name VARCHAR2(50)
);

CREATE TABLE Student_Audit (
AuditID NUMBER GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,
StudentID NUMBER,
StudentName VARCHAR2(50),
Action VARCHAR2(20),
ActionDate DATE
);

-- AFTER INSERT row-level trigger to capture inserts
CREATE OR REPLACE TRIGGER trg_students_ins_audit
AFTER INSERT ON Students
FOR EACH ROW
BEGIN
INSERT INTO Student_Audit (StudentID, StudentName, Action, ActionDate)
VALUES (:NEW.StudentID, :NEW.Name, 'Inserted', SYSDATE);
END;
/

Dev.to formatting tips

Use fenced code blocks with language hints like ```

Keep one blank line before and after code blocks for clean rendering in Markdown-based editors like Dev.to.
If showing code that itself contains backticks, use a longer fence (four or more backticks) to avoid premature closing in Markdown processors.

This post is dedicated to @santhoshnc Sir thank you for the assignment and continuous support.

📝 Understanding Transactions, Deadlocks & Log-Based Recovery in SQL 💾

BHARANIKA D 24CB005 — Sat, 01 Nov 2025 07:17:56 +0000

👋 Introduction

Have you ever wondered what happens when two people try to withdraw money from the same bank account at the same time?
Databases handle such cases using transactions, locks, and recovery logs
to make sure data always stays consistent.

In this blog, we’ll explore:

How transactions maintain atomicity
What a deadlock is and how it’s detected
How log-based recovery ensures data safety after a crash

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);

⚙️ 2️⃣ Transaction – Atomicity & Rollback

🧠 Concept:
A transaction ensures that all steps succeed or none at all.
If any step fails, the database will rollback to the previous stable state.

START TRANSACTION;
UPDATE Accounts
SET balance = balance - 500
WHERE name = 'Alice';
UPDATE Accounts
SET balance = balance + 500
WHERE name = 'Bob';
SELECT * FROM Accounts;
ROLLBACK;
SELECT * FROM Accounts;

✅ Result:
All updates are undone after rollback → no partial transaction is saved.
This proves Atomicity — either all or none of the operations take effect.

🔄 3️⃣ Deadlock Simulation

🧠 Concept:
A deadlock happens when two transactions wait forever because each holds a lock the other needs.
Let’s simulate it using two SQL sessions.
🪟 Session 1:

START TRANSACTION;
UPDATE Accounts SET balance = balance - 100 WHERE name = 'Alice'; 
UPDATE Accounts SET balance = balance + 100 WHERE name = 'Bob';

🪟 Session 2:

START TRANSACTION;
UPDATE Accounts SET balance = balance - 50 WHERE name = 'Bob';
UPDATE Accounts SET balance = balance + 50 WHERE name = 'Alice';

📜 4️⃣ Log-Based Recovery

🧠 Concept:
Every database maintains logs (like MySQL Binary Logs or PostgreSQL WAL) that record each change.
If a crash happens, the DB can redo committed and undo uncommitted transactions.

SHOW VARIABLES LIKE 'log_bin';
START TRANSACTION;
UPDATE Accounts SET balance = 900 WHERE name = 'Alice';
ROLLBACK;

Then check the logs:

SHOW BINLOG EVENTS LIMIT 10;

You’ll see records for the update and rollback.

✅ Result:
The undo operation is recorded, ensuring the database can recover correctly after any failure.

🧠 Conclusion

Through this activity, we learned:

Transactions ensure data integrity (Atomicity, Consistency)
Deadlocks are automatically detected and handled by DBMS
Logs help recover data during failures

💡 Key takeaway: Databases are smart enough to protect your data even when things go wrong!

SQL

BHARANIKA D 24CB005 — Sat, 23 Aug 2025 01:47:03 +0000

🚀 SQL Lab Experiments with Oracle LiveSQL

Hi everyone 👋,

I worked on my SQL lab using Oracle LiveSQL. Below are the codes I practiced, step by step – from table creation to queries.

🔹 Step 1 – Create Tables
CREATE TABLE Students (
StudentID INT PRIMARY KEY,
StudentName VARCHAR(100),
Dept VARCHAR(50),
Email VARCHAR(100)
);

CREATE TABLE Courses (
CourseID INT PRIMARY KEY,
CourseName VARCHAR(100),
Credits INT
);

CREATE TABLE Enrollments (
EnrollID INT PRIMARY KEY,
StudentID INT,
CourseID INT,
Grade CHAR(2),
FOREIGN KEY (StudentID) REFERENCES Students(StudentID),
FOREIGN KEY (CourseID) REFERENCES Courses(CourseID)
);

🔹 Step 2 – Insert Data
INSERT INTO Students (StudentID, StudentName, Dept, Email)
VALUES (3, 'Rahul Verma', 'CSE', 'rahul@college.com');

INSERT INTO Courses (CourseID, CourseName, Credits)
VALUES (103, 'Networks', 3);

INSERT INTO Enrollments (EnrollID, StudentID, CourseID, Grade)
VALUES (3, 3, 103, 'A');

🔹 Step 3 – Queries

Select all students SELECT * FROM Students;

Select all courses
SELECT * FROM Courses;
Select all enrollments
SELECT * FROM Enrollments;

Join Students & Enrollments
SELECT S.StudentName, E.Grade
FROM Students S
JOIN Enrollments E ON S.StudentID = E.StudentID;
Join Students, Courses & Enrollments
SELECT S.Name, C.CourseName, E.Grade
FROM Enrollments E
JOIN Students S ON E.StudentID = S.StudentID
JOIN Courses C ON E.CourseID = C.CourseID;

Find students in CSE dept
SELECT StudentName
FROM Students
WHERE Dept = 'CSE';
Count total students
SELECT COUNT(*) AS TotalStudents
FROM Students;
Student count by department
SELECT Dept, COUNT(*) AS StudentCount
FROM Students
GROUP BY Dept;

Create a view
CREATE OR REPLACE VIEW StudentCoursesView AS
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;
Stored procedure to update grade
CREATE OR REPLACE PROCEDURE UpdateGrade (
p_StudentID IN INT,
p_CourseID IN INT,
p_NewGrade IN CHAR
) AS
BEGIN
UPDATE Enrollments

SET Grade = p_NewGrade WHERE StudentID = p_StudentID AND CourseID = p_CourseID; END; /

✅ Final Output Example

One student: Rahul Verma (CSE)

One course: Networks

Enrollment: Grade A (later updated to B)

💡 This was my SQL lab practice using Oracle LiveSQL. Simple, clean, and working!