Forem: Nethra Loganathan

AWS Service: Amazon Neptune

Nethra Loganathan — Thu, 18 Dec 2025 16:46:14 +0000

Service Overview

Amazon Neptune is a fully managed graph database service designed for applications that work with highly connected data such as social networks, recommendation engines, fraud detection, and knowledge graphs.

It supports popular graph models like Property Graph and RDF.

Key Features

Fully managed and highly available

Supports Gremlin and SPARQL query languages

Optimized for graph workloads

Automatic backups and replication

Secure with encryption at rest and in transit

Scales to billions of relationships

AWS Category / Cloud Domain

Category: Database

Cloud Domain: Database as a Service (DBaaS)

Where It Fits in Cloud / DevOps Lifecycle

Develop: Build graph-based applications

Deploy: Managed database deployment

Operate: AWS handles scaling, backups, and patching

Scale: Automatically scales with workload

Used in DevOps for data-driven, real-time applications.

Programming Language / Access Methods

Query Languages:

Gremlin

SPARQL

Access Methods:

AWS Management Console

AWS CLI

AWS SDKs (Python, Java, JavaScript, etc.)

Pricing Model

➡ Pay-as-you-go

➡ Charged based on:

➡ Instance hours

➡ Storage used

➡ I/O operations

➡ Data transfer

➡ No upfront cost

DevSecOps Periodic Table-Tekton (TK)

Nethra Loganathan — Thu, 18 Dec 2025 16:35:36 +0000

Overview of the Tool

Tekton is an open-source Kubernetes-native CI/CD framework used to build, test, and deploy applications. It provides reusable and scalable pipeline components that run entirely on Kubernetes.

Tekton helps teams automate software delivery while integrating security checks, making it suitable for DevSecOps environments.

Key Features
Kubernetes-native CI/CD pipelines

Declarative pipeline definitions using YAML

Reusable pipeline components (Tasks & Pipelines)

Cloud-native and scalable

Easy integration with security tools (SAST, container scanning)

Works well with GitHub, GitLab, Docker, Kubernetes

How It Fits into DevOps / DevSecOps

Automates build, test, and deploy stages

Enables CI/CD pipelines inside Kubernetes

Supports shift-left security by integrating security scans

Used to enforce secure software delivery practices

Bridges Development + Security + Operations

Programming Language

Written in Go (Golang)

Pipelines are defined using YAML

Parent Company

Originally developed by Google

Now maintained by the Continuous Delivery Foundation (CDF)

Open Source or Paid

Fully Open Source

Free to use

Conclusion

Tekton is a powerful cloud-native CI/CD tool that plays a key role in DevSecOps by enabling secure, automated, and scalable software delivery pipelines on Kubernetes.

Database Normalization in Oracle SQL — From 1NF to 3NF with Example

Nethra Loganathan — Sun, 05 Oct 2025 07:37:40 +0000

Normalization is a process that helps to remove redundancy, avoid anomalies, and improve data consistency in a relational database.
Step 1: Understanding Data Anomalies

Before normalization, let’s look at an unnormalized table:

Anomalies Present

Insertion Anomaly: Can’t insert a new course unless a student takes it.

Update Anomaly: Changing an instructor’s phone requires multiple updates.

Deletion Anomaly: Deleting a student may also delete course information.

Step 2: Conversion to 1NF

In 1NF, each field holds only one value — our table already follows this form.

CREATE TABLE StudentCourseInfo (
StudentID VARCHAR2(10),
StudentName VARCHAR2(50),
CourseID VARCHAR2(10),
CourseName VARCHAR2(50),
Instructor VARCHAR2(50),
InstructorPhone VARCHAR2(15)
);

Step 3: Conversion to 2NF

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

CREATE TABLE Students (
StudentID VARCHAR2(10) PRIMARY KEY,
StudentName VARCHAR2(50)
);

CREATE TABLE Courses (
CourseID VARCHAR2(10) PRIMARY KEY,
CourseName VARCHAR2(50),
Instructor VARCHAR2(50),
InstructorPhone VARCHAR2(15)
);

In 3NF, we remove transitive dependencies — instructor details are separated into their own table.

CREATE TABLE Instructors (
InstructorID INT GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,
InstructorName VARCHAR2(50),
InstructorPhone VARCHAR2(15)
);

CREATE TABLE Courses (
CourseID VARCHAR2(10) PRIMARY KEY,
CourseName VARCHAR2(50),
InstructorID INT,
FOREIGN KEY (InstructorID) REFERENCES Instructors(InstructorID)
);

CREATE TABLE Students (
StudentID VARCHAR2(10) PRIMARY KEY,
StudentName VARCHAR2(50)
);

CREATE TABLE StudentCourses (
StudentID VARCHAR2(10),
CourseID VARCHAR2(10),
PRIMARY KEY (StudentID, CourseID),
FOREIGN KEY (StudentID) REFERENCES Students(StudentID),
FOREIGN KEY (CourseID) REFERENCES Courses(CourseID)
);
Step 5: Inserting Sample Data
-- Insert Students
INSERT INTO Students VALUES ('S01', 'Arjun');
INSERT INTO Students VALUES ('S02', 'Priya');
INSERT INTO Students VALUES ('S03', 'Kiran');

-- Insert Instructors
INSERT INTO Instructors (InstructorName, InstructorPhone)
VALUES ('Dr.Kumar', '9876543210');
INSERT INTO Instructors (InstructorName, InstructorPhone)
VALUES ('Dr.Mehta', '9123456780');
INSERT INTO Instructors (InstructorName, InstructorPhone)
VALUES ('Dr.Rao', '9988774455');

-- Insert Courses
INSERT INTO Courses (CourseID, CourseName, InstructorID)
VALUES ('C101', 'DBMS', 1);
INSERT INTO Courses (CourseID, CourseName, InstructorID)
VALUES ('C102', 'Data Mining', 2);
INSERT INTO Courses (CourseID, CourseName, InstructorID)
VALUES ('C103', 'AI', 3);

-- Insert Mapping
INSERT INTO StudentCourses VALUES ('S01', 'C101');
INSERT INTO StudentCourses VALUES ('S01', 'C102');
INSERT INTO StudentCourses VALUES ('S02', 'C103');

Step 6: Joining Tables to Display Final Output

Let’s join all tables to display Student Name, Course, and Instructor:

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

Cursor & Trigger in SQL with Examples

Nethra Loganathan — Sat, 04 Oct 2025 03:37:12 +0000

In this blog, we’ll explore two important SQL concepts: Cursors and Triggers.
We’ll walk through step-by-step examples:

A cursor that displays employee names with salary greater than 50,000.

An AFTER INSERT trigger that logs student registrations into an audit table.

Part 1: Cursor – Process Cursor with Condition
Problem Statement

We need to create a cursor that displays employee names whose salary is greater than 50,000 from the Employee table.

Steps

Create Employee Table
CREATE TABLE Employee (
EmpID INT PRIMARY KEY,
EmpName VARCHAR(50),
Salary DECIMAL(10,2)
);
Insert Sample Records
INSERT INTO Employee (EmpID, EmpName, Salary) VALUES
(1, 'Alice', 60000),
(2, 'Bob', 48000),
(3, 'Charlie', 75000),
(4, 'David', 45000),
(5, 'Eve', 90000);
Create and Use the Cursor
DECLARE @EmpName VARCHAR(50), @Salary DECIMAL(10,2);

DECLARE EmployeeCursor CURSOR FOR
SELECT EmpName, Salary
FROM Employee
WHERE Salary > 50000;

OPEN EmployeeCursor;

FETCH NEXT FROM EmployeeCursor INTO @EmpName, @Salary;

WHILE @@FETCH_STATUS = 0
BEGIN
PRINT 'Employee: ' + @EmpName + ' | Salary: ' + CAST(@Salary AS VARCHAR);
FETCH NEXT FROM EmployeeCursor INTO @EmpName, @Salary;
END;

CLOSE EmployeeCursor;
DEALLOCATE EmployeeCursor;

Output Example Employee: Alice | Salary: 60000 Employee: Charlie | Salary: 75000 Employee: Eve | Salary: 90000

Part 2: Trigger – AFTER INSERT on Student Table
Problem Statement

Whenever a new student is added to the Students table, we want to automatically insert a log entry into the Student_Audit table.

Steps

Create Students Table
CREATE TABLE Students (
StudentID INT PRIMARY KEY,
StudentName VARCHAR(50),
Department VARCHAR(50)
);
Create Student_Audit Table
CREATE TABLE Student_Audit (
AuditID INT IDENTITY(1,1) PRIMARY KEY,
StudentID INT,
Action VARCHAR(50),
ActionDate DATETIME
);
Create the Trigger
CREATE TRIGGER trg_AfterStudentInsert
ON Students
AFTER INSERT
AS
BEGIN
INSERT INTO Student_Audit (StudentID, Action, ActionDate)
SELECT StudentID, 'INSERT', GETDATE()
FROM inserted;
END;
Test the Trigger by Inserting a Student
INSERT INTO Students (StudentID, StudentName, Department)
VALUES (101, 'Rahul', 'Computer Science');
Check the Audit Table
SELECT * FROM Student_Audit;

Conclusion

With cursors, we can process query results row by row and apply conditions (like salary > 50,000).

With triggers, we can automate actions — in this case, logging every student registration.

CRUD Operations in MongoDB

Nethra Loganathan — Sat, 04 Oct 2025 02:59:13 +0000

Introduction

MongoDB is one of the most popular NoSQL databases used for building modern, scalable applications. Unlike traditional relational databases, MongoDB stores data in flexible JSON-like documents, making it perfect for handling real-world scenarios.

In this blog, we’ll explore CRUD operations (Create, Read, Update, Delete) with MongoDB using a simple example — a college student database.

1.create (Insert)

We start by inserting student records into our students collection.

Each student is stored as a document:

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

Insert multiple students at once:

use college;

db.students.insertMany([
{
"student_id": "S001",
"name": "Santhosh",
"age": 20,
"department": "Computer Science",
"year": 2,
"cgpa": 9
},
{
"student_id": "S002",
"name": "Priya",
"age": 21,
"department": "Computer Science",
"year": 3,
"cgpa": 8.5
},
{
"student_id": "S003",
"name": "Arjun",
"age": 19,
"department": "Electronics",
"year": 3,
"cgpa": 7.2
},
{
"student_id": "S004",
"name": "Meera",
"age": 22,
"department": "Computer Science",
"year": 1,
"cgpa": 6.8
},
{
"student_id": "S005",
"name": "Nethra",
"age": 20,
"department": "CSBS",
"year": 3,
"cgpa": 9.2
}
]);

2.read (Query)

Fetch all students:

db.students.find({});

Find all students with CGPA > 8:

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

Find all students belonging to the CSE department:

db.students.find({ department: "Computer Science" });

3.Update

Update the CGPA of a specific student:

db.students.updateOne(
{ student_id: "S005" },
{ $set: { cgpa: 9.2};

Increase year of study for all 3rd-year students:

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

4.Delete

Delete one student record by ID:

db.students.deleteOne({ student_id: "S004" });

Delete all students with CGPA < 7.5:

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

Conclusion

In this blog, we explored how to perform CRUD operations in MongoDB with a student database.

We:
✔ Inserted multiple student records
✔ Queried documents with filters
✔ Updated single and multiple documents
✔ Deleted records selectively

DBMS-Transaction, Deadlocks & Log-Based Recovery

Nethra Loganathan — Sat, 04 Oct 2025 01:55:05 +0000

STEP 1: Create table and Insert data

CREATE TABLE CustomerAccounts (
acc_no INT PRIMARY KEY,
name VARCHAR2(50),
balance INT
);

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

SELECT * FROM CustomerAccounts;

Step 2: Transaction – Atomicity & Rollback

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;

Step 3: Deadlock Simulation (Conceptual)

Session 1 (conceptual)

-- Lock Alice
UPDATE CustomerAccounts SET balance = balance - 100 WHERE name = 'Alice';
-- Do NOT commit

Session 2 (conceptual)
-- Lock Bob
UPDATE CustomerAccounts SET balance = balance - 200 WHERE name = 'Bob';
-- Do NOT commit

Continuing Session 1
-- Try updating Bob (held by Session 2)
UPDATE CustomerAccounts SET balance = balance + 100 WHERE name = 'Bob';

Continuing Session 2
-- Try updating Alice (held by Session 1)
UPDATE CustomerAccounts SET balance = balance + 200 WHERE name = 'Alice';

Expected in a real multi-session DB:

ORA-00060: deadlock detected while waiting for resource.

Step 4: Log-Based Recovery

UPDATE CustomerAccounts
SET balance = balance + 200;
WHERE name = 'Charlie';

ROLLBACK;

SELECT * FROM CustomerAccounts;