Forem: NatpuEnean VA

Neo4j – The Leading Open-Source Graph Database Every Developer Should Know

NatpuEnean VA — Fri, 19 Dec 2025 08:40:53 +0000

Modern applications generate data that is deeply connected—users, purchases, relationships, activities.
Traditional relational databases struggle when the number of joins increases.

Neo4j solves that problem elegantly.

** What is Neo4j?
**
Neo4j is a popular open-source, NoSQL graph database built for storing and querying connected data.

Instead of tables, rows, and columns, Neo4j uses:

Nodes – entities/objects

Relationships – links between nodes

Properties – metadata that describes nodes & relationships

This structure allows queries to traverse connected paths extremely efficiently.

Why developers love Neo4j

Neo4j provides:

Fast relationship traversal

Simple and expressive query language (Cypher)

ACID-compliant transactions

Native graph storage engine

Strong community + active ecosystem

You don’t need complex joins – relationships are first-class citizens.

Use cases for Neo4j

Neo4j shines when data is highly connected:

Social networks

Knowledge graphs

Fraud detection patterns

Recommendation engines

Identity + access management

Network + IT dependency mapping

Any domain where relationships matter → Neo4j becomes powerful.

Install & Set Up Neo4j (Developer Steps)

Download Neo4j Community Edition
Start local DB instance
Open Neo4j Browser at localhost:7474
Authenticate + begin modeling your graph

Example: Creating and Querying Nodes with Cypher

Create two users:

CREATE (u1:User {name:'Alice'}),
(u2:User {name:'Bob'});

Create a relationship:

MATCH (u1:User {name:'Alice'}), (u2:User {name:'Bob'})
CREATE (u1)-[:FOLLOWS]->(u2);

Query connections:

MATCH (u:User)-[:FOLLOWS]->(friend)
RETURN u.name, friend.name;

That's a 3-line traversal that would take multiple JOINs in SQL.

Why Choose Neo4j Instead of SQL for Connected Data?

SQL works great for structured, transactional use cases.
But when queries require:

Many levels of relationships

Pattern matching

Path finding

Graph models outperform relational systems.

Neo4j makes these queries natural and scalable.

Open-Source Advantages

Neo4j’s open-source nature means:

Transparent development

Active community support

Free to get started

Tons of extensions + integrations

Neo4j integrates easily with:

Python, JavaScript, Java, Go, etc.

Spring Boot

GraphQL

Apache Kafka

Final Thoughts

Neo4j is a powerful tool for developers building graph-driven applications.

Whether you’re developing:

social platforms,

recommendation engines, or

fraud-detection systems,

Neo4j provides the modeling flexibility and performance needed for connected data at scale.

If you've never worked with graph databases, Neo4j is the deepest and easiest open-source entry point to begin your journey

Getting Started With Amazon Neptune – A Graph Database for Modern Apps

NatpuEnean VA — Fri, 19 Dec 2025 08:38:11 +0000

When building modern applications, one challenge developers face is modeling complex relationships between data. Traditional relational databases struggle when relationships become deeply connected.

This is where Amazon Neptune comes in.

What is Amazon Neptune?

Amazon Neptune is a fully managed graph database service by AWS designed to store and query highly connected datasets.

Instead of storing tables and joins, Neptune stores nodes and edges, making relationship queries more natural and faster.

It supports two major graph models:

Property Graph using Apache TinkerPop Gremlin

W3C RDF using SPARQL

This lets developers choose an approach that suits their application.

Why use Neptune instead of SQL?

Neptune shines when:

You need to find relationships quickly

Your data constantly grows with new connections

Queries require traversing multiple hops

Example use cases:

Social networks (followers → mutual friends → interests)

Fraud detection (tracking suspicious transactions)

Recommendation engines (users → purchases → products)

Knowledge graphs (concepts → relationships)

Doing these in SQL means expensive JOINs and slow performance. Neptune makes relationship queries efficient.

How Neptune Works

Neptune stores data using:

Vertices (nodes) – represent objects

Edges – represent relationships

Properties – describe nodes and edges

Example:

User ── follows ──> User
User ── purchased ──> Product
Product ── belongsTo ──> Category

You can then query patterns like:

“Find all users who bought products in category X that their friends purchased.”

Getting Started With Neptune

Here's a simple workflow for developers:

Create a Neptune DB Cluster

Open AWS console

Search for Amazon Neptune

Choose instance type + VPC settings

Connect using Gremlin or SPARQL

Example Gremlin command to add a user vertex:

g.addV("user").property("id","u1").property("name","Natpu")

Add a relationship:

g.V("u1").addE("follows").to(g.V("u2"))

Query mutual connections:

g.V("u1").out("follows").out("follows")

That’s how easy traversals become.

Security & Performance Benefits

Neptune integrates with AWS services:

VPC networking

IAM authentication

Encryption at rest + in transit

Built-in backups + monitoring

Millisecond latency on graph traversals

You focus on queries instead of managing databases.

When Should Developers Choose Neptune?

Use Neptune if:

✔ Your data is relationship-heavy
✔ Query performance matters
✔ JOINs are becoming too complex
✔ You want fully managed infrastructure

Avoid Neptune if:

✖ Your dataset is simple
✖ Relationships are shallow
✖ A relational DB is sufficient

Final Thoughts

Amazon Neptune opens powerful opportunities for developers building intelligent apps based on relationships.

Whether you're working on social graphs, recommendation engines, or fraud detection, Neptune offers performance, ease of management, and flexibility in query languages.

If you’re exploring graph databases for the first time, Neptune is a strong AWS-native option to start with.

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

NatpuEnean VA — Sun, 05 Oct 2025 11:00:52 +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.

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;

Transactions, Deadlocks & Log-Based Recovery

NatpuEnean VA — Thu, 02 Oct 2025 06:03:11 +0000

Transactions (Atomicity & Rollback)

Deadlock Simulation

Log-Based Recovery

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

Initial state of table:

acc_no name balance
1 Alice 1000
2 Bob 1500
3 Charlie 2000
Transaction – Atomicity & Rollback

We want to transfer 500 from Alice → Bob inside a transaction but rollback before commit.

-- Start transaction
START TRANSACTION;

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

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

-- Rollback instead of commit
ROLLBACK;

Verification
SELECT * FROM Accounts;

Balances remain unchanged (no partial update):

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

This proves Atomicity: either all updates happen, or none.

Deadlock Simulation

We’ll open two SQL sessions to simulate a deadlock.

Session 1
START TRANSACTION;
-- Lock Alice’s account
UPDATE Accounts SET balance = balance - 100 WHERE name = 'Alice';

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

Session 2
START TRANSACTION;
-- Lock Bob’s account
UPDATE Accounts SET balance = balance - 100 WHERE name = 'Bob';

-- Now try to update Alice (this will wait if Session 1 has Alice locked)
UPDATE Accounts SET balance = balance + 100 WHERE name = 'Alice';

At this point:

Session 1 is waiting for Bob (locked by Session 2).

Session 2 is waiting for Alice (locked by Session 1).

This is a deadlock.

Most databases (Oracle, MySQL, PostgreSQL, SQL Server) will detect the deadlock and automatically kill one transaction, rolling it back.

You’ll see an error like:

ERROR 1213 (40001): Deadlock found when trying to get lock

Log-Based Recovery

Databases maintain logs (MySQL = Binary Log, PostgreSQL = WAL, Oracle = Redo Logs). These logs allow recovery during crashes or rollbacks.

Example – Transaction with rollback
START TRANSACTION;

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

ROLLBACK;

The update is written to the log.

The rollback adds a corresponding undo entry.

If the system crashes, the recovery process replays the log and ensures Charlie’s balance remains unchanged.

Cursor & Trigger with Examples

NatpuEnean VA — Thu, 02 Oct 2025 05:35:58 +0000

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 the Employee table (if not already available):

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

Insert some 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

Only employees with salaries greater than 50,000 will be displayed:

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

📌 Part 2: Trigger – AFTER INSERT Trigger 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 new student:

INSERT INTO Students (StudentID, StudentName, Department)
VALUES (101, 'Rahul', 'Computer Science');

Check the Audit table:

SELECT * FROM Student_Audit;

Output Example

AuditID | StudentID | Action | ActionDate

1 | 101 | INSERT | 2025-10-02 10:15:32

CRUD Operations in MongoDB Atlas – A Beginner’s Guide with Student Database Example

NatpuEnean VA — Wed, 01 Oct 2025 14:01:00 +0000

Introduction

MongoDB is one of the most popular NoSQL databases used by developers today for building modern, scalable applications. Unlike traditional relational databases, MongoDB stores data in flexible JSON-like documents, making it easier to work with real-world scenarios.

In this blog, I’ll walk you through CRUD operations (Create, Read, Update, Delete) in MongoDB using a simple example: a college student database.

We’ll:

Insert student details

Query them with filters

Update academic information

Delete records when needed

To make it more exciting, we’ll run these queries directly on MongoDB Atlas Cluster (cloud-based MongoDB). You can also include screenshots of the MongoDB Atlas dashboard and outputs so readers can follow visually.

Outcome

By the end of this blog, you’ll learn:

How to insert multiple documents into a collection

How to read and filter records using queries

How to update documents (single & multiple)

How to delete documents based on conditions

How CRUD fits into real-world development

Setup: Creating a Cluster

Create a free MongoDB Atlas account → MongoDB Atlas

Create a cluster (choose the free tier).

Inside the cluster, create a database called collegeDB.

Inside collegeDB, create a collection called students.

Create (Insert)

We’ll start by inserting student records into our students collection.

Each student is stored as a separate document:

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

{
"student_id": "S002",
"name": "Natpu",
"age": 20,
"department": "CSBS",
"year": 2,
"cgpa": 9
}

Insert multiple documents:

db.students.insertMany([
{
student_id: "S001",
name: "Kavin",
age: 20,
department: "CSBS",
year: 2,
cgpa: 9
},
{
student_id: "S002",
name: "Natpu",
age: 20,
department: "CSBS",
year: 2,
cgpa: 9
}
])

Read (Query)

Fetch all students:

db.students.find({})

Find all students with CGPA > 8:

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

Find students belonging to Computer Science department:

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

Update

Update 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 } }
)

Delete

Delete one student record by ID:

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

Delete all students having CGPA < 7.5:

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

Troubleshooting: JSON Error in Node.js

If you’re connecting MongoDB with a Node.js backend, you might run into this error:

Failed to execute 'json' on 'Response': Unexpected end of JSON input

app.post("/students", async (req, res) => {
try {
const result = await db.collection("students").insertOne(req.body);
res.json({ success: true, id: result.insertedId });
} catch (err) {
res.status(500).json({ error: err.message });
}
});

On the frontend, check if the response has content before parsing:

const response = await fetch("/students");
let data = {};

try {
data = await response.json();
} catch (e) {
console.warn("Empty or invalid JSON response");
}

Conclusion

In this blog, we explored how to perform CRUD operations in MongoDB using a real-world example of a student database.

We:

Inserted multiple records

Queried documents with conditions

Updated both single and multiple entries

Deleted documents selectively

CRUD operations form the building blocks of every application, whether you’re managing users in a website, products in an e-commerce app, or students in a college system.

This step-by-step approach not only gave us hands-on practice with MongoDB but also demonstrated how database schemas fit into real-world academic systems.

Thanks to @santhoshnc sir for guiding and motivating us.

College Student & Course Management System

NatpuEnean VA — Thu, 21 Aug 2025 14:28:37 +0000

Introduction
This blog covers the implementation of a simple College Student & Course Management System using SQL on Oracle LiveSQL. It demonstrates key database concepts such as table creation, data insertion, constraint addition, queries with functions and aggregates, joins, views, and stored procedures.

The use case focuses on managing students, courses, enrollments, and faculty members with related operations.

Database Schema

The database contains four main tables: Students, Courses, Enrollments, and Faculty.

Students Table

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

Course Table

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

Enrollments Table

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

Faculty Table

CREATE TABLE Faculty (
FacultyID NUMBER PRIMARY KEY,
FacultyName VARCHAR2(50) NOT NULL,
Dept VARCHAR2(30),
Email VARCHAR2(50) UNIQUE
);

Data Insertion
INSERT INTO Students (StudentID, Name, Dept, DOB, Email)
VALUES (1, 'Daniel Green', 'Information Technology', TO_DATE('2002-02-10', 'YYYY-MM-DD'), 'daniel.green@example.com');

INSERT INTO Students (StudentID, Name, Dept, DOB, Email)
VALUES (2, 'Emma White', 'Electronics', TO_DATE('2001-08-05', 'YYYY-MM-DD'), 'emma.white@example.com');

INSERT INTO Students (StudentID, Name, Dept, DOB, Email)
VALUES (3, 'Frank Lee', 'Mechanical', TO_DATE('2003-01-19', 'YYYY-MM-DD'), 'frank.lee@example.com');

INSERT INTO Courses (CourseID, CourseName, Credits) VALUES (201, 'Operating Systems', 4);
INSERT INTO Courses (CourseID, CourseName, Credits) VALUES (202, 'Digital Circuits', 3);
INSERT INTO Courses (CourseID, CourseName, Credits) VALUES (203, 'Thermodynamics', 5);

INSERT INTO Enrollments (EnrollID, StudentID, CourseID, Grade) VALUES (1, 1, 201, 'A');
INSERT INTO Enrollments (EnrollID, StudentID, CourseID, Grade) VALUES (2, 2, 202, 'B');
INSERT INTO Enrollments (EnrollID, StudentID, CourseID, Grade) VALUES (3, 3, 203, 'A-');

Table Alterations and Constraints

ALTER TABLE Students ADD PhoneNo VARCHAR2(10);

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

SQL Queries with Functions and Aggregates
Example 1: Listing student names in uppercase and length of their emails

SELECT UPPER(Name) AS UppercaseName, LENGTH(Email) AS EmailLength
FROM Students;

UppercaseName	EmailLength
DANIEL GREEN	24
EMMA WHITE	22
FRANK LEE	21

Example 2: Calculating average course credits and counting enrolled students

SELECT
(SELECT AVG(Credits) FROM Courses) AS AvgCredits,
(SELECT COUNT(DISTINCT StudentID) FROM Enrollments) AS TotalStudentsEnrolled
FROM dual;

AvgCredits	TotalStudentsEnrolled
4.0	3

JOIN Queries

Joining Students, Enrollments, and Courses to show which student is enrolled in which course along with grades:

SELECT s.Name AS StudentName, c.CourseName, e.Grade
FROM Students s
JOIN Enrollments e ON s.StudentID = e.StudentID
JOIN Courses c ON c.CourseID = e.CourseID;

StudentName	CourseName	Grade
Daniel Green	Operating Systems	A
Emma White	Digital Circuits	B
Frank Lee	Thermodynamics	A-

GROUP BY and HAVING Clause

Counting students in each department and filtering departments with more than 1 student:

SELECT Dept, COUNT() AS StudentCount
FROM Students
GROUP BY Dept
HAVING COUNT() > 1;

Dept	StudentCount
(No dept with >1 student in current data)

Views

CREATE OR REPLACE VIEW StudentCoursesView AS
SELECT s.Name AS StudentName, c.CourseName, e.Grade
FROM Students s
JOIN Enrollments e ON s.StudentID = e.StudentID
JOIN Courses c ON c.CourseID = e.CourseID;

Stored Procedure

CREATE OR REPLACE PROCEDURE UpdateGrade (
p_StudentID IN NUMBER,
p_CourseID IN NUMBER,
p_NewGrade IN CHAR
) AS
BEGIN
UPDATE Enrollments
SET Grade = p_NewGrade
WHERE StudentID = p_StudentID AND CourseID = p_CourseID;
COMMIT;
END;

Summary

This assignment reinforced understanding of:

Creating and managing SQL database schemas

Writing data manipulation queries

Using SQL functions and aggregate operations

Performing joins to combine related data

Creating views and stored procedures to enhance SQL capabilities

You can try the full script on Oracle LiveSQL to see these operations in action.