No-SQL Unit 4: Complete Concepts Guide

1. Introduction to Graph DatabasesCopy Anchor Link

1.1 What is a Graph Database?Copy Anchor Link

A graph database is a type of NoSQL database that stores and represents data as a graph, using nodes, relationships, and properties. It is designed to efficiently manage and query highly connected data, where the relationships between entities are as important as the entities themselves.

1.2 Core Components of a GraphCopy Anchor Link

1.3 Example: Social NetworkCopy Anchor Link

Person Node (Alice)              Person Node (Bob)
Properties:                      Properties:
name: "Alice"                    name: "Bob"
age: 25                          age: 27
city: "Bangalore"                city: "Mumbai"
      │                                │
      │ FRIEND_OF (since: 2020)        │
      └────────────────────────────────┘
      │                                │
      │ LIVES_IN                       │ WORKS_AT
      ↓                                ↓
City Node (Bangalore)          Company Node (ABC Corp)
Properties:                     Properties:
name: "Bangalore"              name: "ABC Corp"
country: "India"               industry: "IT"
                               location: "Bangalore"

1.4 In Simple TermsCopy Anchor Link

Nodes = Things
Relationships = Connections
Properties = Details about things/connections

1.5 Why Graph Databases?Copy Anchor Link

Graph databases are ideal when:

• Relationships are first-class citizens — stored directly, not inferred via joins
• Highly connected data — social networks, recommendations, fraud detection
• Complex traversals — friends-of-friends, shortest paths
• Evolving schema — flexible, schema-optional

2. Relational Databases vs Graph DatabasesCopy Anchor Link

2.1 Comparison TableCopy Anchor Link

2.2 Example: Student DataCopy Anchor Link

Relational Database — Student Table:

Graph Database — Student Graph:

Alice ──FRIEND_OF──→ Bob
  │                    │
  │ STUDIES_AT         │ STUDIES_AT
  ↓                    ↓
ABC University ←───────┘

2.3 In Simple TermsCopy Anchor Link

“Relational databases store data in tables. Graph databases store data as connected entities, making relationships easier and faster to work with.”

3. Property Graph ModelCopy Anchor Link

3.1 What is the Property Graph Model?Copy Anchor Link

The property graph model is a graph data model in which data is represented using nodes and relationships, and both nodes and relationships can have properties in the form of key-value pairs.

3.2 NodesCopy Anchor Link

• Represent entities or objects in the real world
• Can have one or more labels
• Contain a set of properties (key-value pairs)
• Examples: a person, a student, a course, a company

3.3 LabelsCopy Anchor Link

• A label identifies the type or category of a node
• A node can have a single label or multiple labels
• Labels help to group and query nodes
• Examples: Student, Teacher, Course, Company
• Example of multiple labels: {Student:Scholar {name: "Alice"}}

3.4 Relationship TypesCopy Anchor Link

• A relationship type describes the nature of the connection between two nodes
• Relationships are usually directed (from one node to another)
• Can also have properties (key-value pairs)
• Examples: ENROLLED_IN, FRIEND_OF, WORKS_AT, TEACHES, PURCHASED

3.5 Example: University GraphCopy Anchor Link

:Student (Alice)                    :Course (NoSQL)
{id: 1, name: "Alice", age: 20}     {id: 101, name: "NoSQL", credits: 4}
      │                                     │
      │ ENROLLED_IN (year: 2026)            │ TAUGHT_BY (semester: "Fall 2026")
      └─────────────────────────────────────┘
      │                                     │
      │ WORKS_AT (since: 2023)              │
      ↓                                     ↓
:Company (ABC Corp)                 :Teacher (Dr. Kumar)
{id: 201, name: "ABC Corp",         {id: 301, name: "Dr. Kumar",
 industry: "IT"}                     department: "CSE"}

3.6 LegendCopy Anchor Link

3.7 Key TakeawayCopy Anchor Link

In the property graph model, labels tell us what a node is, while relationship types tell us how two nodes are connected.

4. Cypher — Query Language for Neo4jCopy Anchor Link

4.1 What is Cypher?Copy Anchor Link

Cypher is a declarative, SQL-like query language used in Neo4j to create, read, update, and delete graph data.

4.2 Cypher Pattern SyntaxCopy Anchor Link

(a:Label)-[r:RELATIONSHIP_TYPE]->(b:Label)

4.3 CREATE ExampleCopy Anchor Link

Create two Person nodes and a FOLLOWS relationship:

CREATE (a:Person {name: 'Alice', age: 25}),
       (b:Person {name: 'Bob', age: 27})
CREATE (a)-[:FOLLOWS]->(b)
RETURN a, b;

Explanation:

• Creates two nodes with the label Person and properties name and age
• Creates a directed relationship of type FOLLOWS from Alice to Bob
• Returns the created nodes

Graph Result:

:Person (Alice)  ──FOLLOWS──→  :Person (Bob)
name: "Alice"                  name: "Bob"
age: 25                        age: 27

4.4 Key PointsCopy Anchor Link

• CREATE is used to add new nodes and relationships
• Nodes are labeled using :Person
• Properties are added as key-value pairs
• Relationships have a type, here FOLLOWS
• The arrow (→) shows the direction (from Alice to Bob)

5. CREATE vs MERGE in CypherCopy Anchor Link

5.1 CREATECopy Anchor Link

• Always creates new nodes or relationships
• Does not check if the data already exists
• Can result in duplicate nodes/relationships if run multiple times
• Useful when you are sure the data does not exist

Example:

CREATE (p:Person {name: 'Alice', age: 25})
RETURN p;

Run twice → Two separate nodes (duplicates):

:Person (Alice)  :Person (Alice)
name: "Alice"    name: "Alice"
age: 25          age: 25

5.2 MERGECopy Anchor Link

• Creates a node or relationship only if it does not exist
• If it exists, it matches the existing one
• Helps avoid duplicate data
• Commonly used to ensure uniqueness

Example:

MERGE (p:Person {name: 'Alice', age: 25})
RETURN p;

Run twice → Only one node created:

:Person (Alice)
name: "Alice"
age: 25

5.3 Comparison TableCopy Anchor Link

5.4 Key TakeawayCopy Anchor Link

“Use CREATE when you want to always create. Use MERGE when you want to create only if it doesn’t exist (otherwise match).”

6. Graph TraversalCopy Anchor Link

6.1 What is Graph Traversal?Copy Anchor Link

Graph traversal is the process of navigating through a graph by following relationships (edges) from one node to another to find connected nodes.

6.2 Example Graph: Social NetworkCopy Anchor Link

        Carol
          ↑
          │ FOLLOWS
          │
David ←─────── Alice ───────→ Bob
  FOLLOWS     (center)    FOLLOWS

6.3 One-Hop TraversalCopy Anchor Link

Find the immediate neighbors (directly connected nodes) from a given node.

Cypher Query:

MATCH (a:Person {name: 'Alice'})-[:FOLLOWS]->(b:Person)
RETURN b;

Result:

b
Bob
Carol

From Alice, the one-hop traversal returns Bob and Carol (nodes directly connected to Alice).

6.4 Two-Hop TraversalCopy Anchor Link

Find nodes that are two relationships away from a given node.

Cypher Query:

MATCH (a:Person {name: 'Alice'})-[:FOLLOWS]->()-[:FOLLOWS]->(c:Person)
RETURN c;

Result:

c
David

From Alice, the two-hop traversal returns David (a node that is two steps away: Alice → Bob → David).

6.5 Variable-Length TraversalCopy Anchor Link

Find nodes reachable within a variable number of hops.

Cypher Query:

MATCH (a:Person {name: 'Alice'})-[:FOLLOWS*1..3]->(p:Person)
RETURN DISTINCT p.name;

Result:

Bob
Carol
David

6.6 Shortest Path QueryCopy Anchor Link

Find the shortest path between two nodes.

Cypher Query:

MATCH p = shortestPath(
    (a:Person {name: 'Alice'})-[:FOLLOWS*]-(e:Person {name: 'Eve'})
)
RETURN [n in nodes(p) | n.name] AS path;

Result:

path
["Alice", "Carol", "Eve"]

6.7 Other Traversal TechniquesCopy Anchor Link

6.8 Relationship-Based Search with ConditionsCopy Anchor Link

Find people Alice follows since 2023:

MATCH (a:Person {name: 'Alice'})-[r:FOLLOWS]->(b:Person)
WHERE r.since >= 2023
RETURN b.name, r.since;

Result:

name    since
Bob     2023

6.9 Key TakeawayCopy Anchor Link

Graph traversals in Neo4j help you explore, analyze, and discover relationships in connected data, enabling powerful insights such as recommendations, influence, and network analysis.

7. Graph AlgorithmsCopy Anchor Link

Graph algorithms analyze the structure and relationships in a graph to find meaningful patterns. They help identify important nodes, discover communities, find connections, and measure similarity.

7.1 Algorithm CategoriesCopy Anchor Link

7.2 Centrality AlgorithmsCopy Anchor Link

Measure the importance of nodes based on their position and connections. Help identify key individuals, items, or entities in a network.

Examples:

• PageRank
• Degree Centrality
• Betweenness Centrality
• Closeness Centrality

Example — PageRank:

Measures the importance of nodes based on the number and quality of incoming links. A node is important if it is linked by other important nodes.

A → C ← B
    ↑
    D
    ↑
    E

PageRank Scores:

Use Case: Finding influential users in a social network.

7.3 Community Detection AlgorithmsCopy Anchor Link

Partition the graph into communities where nodes are more connected within the group than with outside nodes. Useful for finding natural groups, such as social circles or customer segments.

Examples:

• Louvain
• Leiden
• Label Propagation
• Weakly Connected Components

Example:

Community 1 (Friends)     Community 2 (Colleagues)
   B ── C                    D ── E
   │    │                    │    │
   A ───┘                    F ───┘

The graph is divided into communities using the Louvain/Leiden algorithm.

Use Case: Detecting groups of users with similar interests.

7.4 Path Finding AlgorithmsCopy Anchor Link

Find paths or shortest routes between nodes. Determine paths based on distance, cost, or other criteria.

Examples:

• Dijkstra’s Shortest Path
• A* Shortest Path
• Breadth-First Search (BFS)
• Depth-First Search (DFS)

Example:

        B
     2 ↗   ↘ 5
A → 1 → C → 2 → E
     4 ↘   ↗ 1
        D

Shortest path from A to E: A → C → E (total cost = 3)

Use Case: Finding the shortest route between two cities.

7.5 Similarity AlgorithmsCopy Anchor Link

Measure how similar two nodes are, typically based on shared neighbors or attributes. Useful for recommendations, fraud detection, and finding similar items or users.

Examples:

• Node Similarity
• K-Nearest Neighbors (KNN)
• Jaccard Similarity
• Cosine Similarity

Example:

     Item A
    ↗      ↘
  U1        U2
    ↘      ↗
     Item B
    ↗      ↘
  U1        U2
    ↘      ↗
     Item C

U1 and U2 are similar because they are connected to the same items (Item A, Item B, Item C).

Similarity Scores:

Use Case: Recommending similar products or suggesting friends.

7.6 Key TakeawayCopy Anchor Link

Graph algorithms turn connected data into actionable insights — helping us find what is important, how things are related, what groups exist, and what is similar, enabling smarter decisions in real-world applications.

8. Graph Analytics Use CasesCopy Anchor Link

8.1 Social Network AnalysisCopy Anchor Link

Graph Model:

Person (Bob) ←─FRIENDS_WITH─→ Person (Alice) ←─FOLLOWS─→ Person (Carol)
                                    │
                          ┌─────────┼─────────┐
                          │         │         │
                       LIKES    CREATED   COMMENTED
                          ↓         ↓         ↓
                       Like      Post      Comment
                                  │
                              HAS_TAG
                                  ↓
                                Tag

8.2 Sample Cypher QueriesCopy Anchor Link

1. Create a user:

CREATE (p:Person {
    userid: 'u1001',
    name: 'Alice',
    age: 25,
    location: 'Bangalore',
    joinDate: date()
});

2. Create a friendship:

MATCH (a:Person {name: 'Alice'}), (b:Person {name: 'Bob'})
MERGE (a)-[:FRIENDS_WITH {since: date()}]->(b);

3. Find a user’s friends:

MATCH (p:Person {name: 'Alice'})-[:FRIENDS_WITH]-(f:Person)
RETURN f.name, f.location;

4. Find posts by a user:

MATCH (p:Person {name: 'Alice'})-[:CREATED]->(post:Post)
RETURN post.postid, post.content, post.createdAt;

5. Add a tag to a post:

MERGE (t:Tag {name: 'Neo4j'})
MATCH (p:Post {postid: 'p100'})
MERGE (p)-[:HAS_TAG]->(t);

6. Find popular posts:

MATCH (p:Post)<-[:LIKES]-(Person)
RETURN p.postid, p.content, count(*) AS likeCount
ORDER BY likeCount DESC
LIMIT 5;

7. Friend recommendations (friends-of-friends):

MATCH (p:Person {name: 'Alice'})-[:FRIENDS_WITH]-(f:Person)
WHERE NOT (p)-[:FRIENDS_WITH]-(f)
AND p <> f
RETURN DISTINCT f.name, f.location
LIMIT 10;

9. Neo4j Architecture OverviewCopy Anchor Link

9.1 What is Neo4j?Copy Anchor Link

Neo4j is a native graph database that stores data as nodes and relationships. It uses a property graph model and provides a high-performance graph engine, Cypher query language, and tools for data management and visualization.

9.2 Architecture LayersCopy Anchor Link

┌─────────────────────────────────────────────────────┐
│  Applications     │  Cypher Query    │  Tools       │
│  (Web, Mobile)    │  Language        │  (Browser,   │
│                   │                  │   Bloom)     │
├─────────────────────────────────────────────────────┤
│           Neo4j Database Engine                     │
│  Stores, indexes, processes and traverses the graph │
├─────────────────────────────────────────────────────┤
│              Graph Storage                          │
│  Nodes │ Relationships │ Labels │ Properties        │
└─────────────────────────────────────────────────────┘

9.3 Property Graph Data ModelCopy Anchor Link

:Person (Alice)  ←──FRIENDS_WITH──→  :Person (Bob)
{name: "Alice",                     {name: "Bob",
 age: 25,                            age: 27,
 location: "Bangalore"}              location: "Mumbai"}
      │                                    │
      │ CREATED                            │ LIKES
      ↓                                    ↓
:Post (Graph DB)                    :Post (Graph DB)
{title: "Graph DB",                 {createdAt: "2024-09-01"}
 content: "Neo4j is amazing!",
 createdAt: "2024-09-01"}

9.4 NodesCopy Anchor Link

• Represent entities (e.g., people, posts, products)
• Can have one or more labels
• Store properties as key-value pairs
• Represent a real-world entity

9.5 RelationshipsCopy Anchor Link

• Connect two nodes and represent how they are related
• Always have a direction (start → end)
• Can have a type (e.g., FRIENDS_WITH, LIKES)
• Can store properties (e.g., since, createdAt)
• Represent meaningful connections between entities

9.6 Labels and PropertiesCopy Anchor Link

Node Labels and Properties:

Relationship Types and Properties:

Key Points:

• Labels define the type of node or relationship
• Properties store information as key-value pairs
• Both labels and properties make the data flexible and easy to query
• You can have multiple labels and multiple properties
• Indexes can be created on labels and properties for faster search

9.7 Key TakeawayCopy Anchor Link

Neo4j’s architecture and property graph model make it ideal for representing and querying highly connected data such as social networks, recommendation systems, fraud detection, knowledge graphs, and more.

10. Graph Traversal in Neo4j — DetailedCopy Anchor Link

10.1 What is Graph Traversal?Copy Anchor Link

Graph traversal is the process of navigating through a graph by following relationships (edges) from one node to another. In Neo4j, traversals are performed using Cypher pattern matching. Traversals can be fixed-length, variable-length, or based on specific conditions such as shortest path.

10.2 Why Use Graph Traversals?Copy Anchor Link

• Find connected data and explore relationships
• Discover hidden patterns and connections
• Build recommendations, perform network analysis
• Understand complex data with simple queries

10.3 Cypher Pattern SyntaxCopy Anchor Link

(a:Label)-[r:RELATIONSHIP_TYPE]->(b:Label)

• Nodes are written in parentheses ( )
• Relationships are written in square brackets [ ]
• Direction is specified using > (outgoing) or <- (incoming)
• Labels and properties can be used to filter results

10.4 Simple Relationship TraversalCopy Anchor Link

Find people that Alice directly follows:

MATCH (a:Person {name: 'Alice'})-[:FOLLOWS]->(b:Person)
RETURN b.name;

Result:

name
Bob

10.5 Variable-Length TraversalCopy Anchor Link

Find people reachable from Alice within 1 to 3 hops:

MATCH (a:Person {name: 'Alice'})-[:FOLLOWS*1..3]->(p:Person)
RETURN DISTINCT p.name;

Result:

name
Bob
Carol
David

10.6 Shortest-Path AnalysisCopy Anchor Link

Find the shortest path between two nodes:

MATCH p = shortestPath(
    (a:Person {name: 'Alice'})-[:FOLLOWS*]-(b:Person {name: 'Eve'})
)
RETURN [n in nodes(p) | n.name] AS path;

Result:

path
["Alice", "Carol", "Eve"]

10.7 Key TakeawaysCopy Anchor Link

• Neo4j stores data as nodes and relationships, making traversals natural and efficient
• Cypher provides a powerful and expressive way to perform graph traversals
• Use relationship-based patterns, variable-length traversals, and shortest path functions to explore and analyze connected data
• Graph traversals enable real-world applications such as friend suggestions, recommendations, fraud detection, and network analysis

11. Unit SummaryCopy Anchor Link

NoSQL UNIT 4 — GRAPH DATABASES, CYPHER, GRAPH ALGORITHMS & NEO4J
│
├── Introduction to Graph Databases
│   ├── Definition (nodes, relationships, properties)
│   ├── Social network example
│   └── Why graph databases
│
├── Relational vs Graph Databases
│   ├── Data model comparison
│   ├── Schema comparison
│   ├── Relationship handling
│   └── Use case comparison
│
├── Property Graph Model
│   ├── Nodes (entities)
│   ├── Labels (categories)
│   ├── Relationship types (connections)
│   ├── Properties (key-value pairs)
│   └── University graph example
│
├── Cypher — Query Language
│   ├── Pattern syntax
│   ├── CREATE example
│   ├── CREATE vs MERGE
│   └── Key points
│
├── Graph Traversal
│   ├── One-hop traversal
│   ├── Two-hop traversal
│   ├── Variable-length traversal
│   ├── Shortest path query
│   ├── DFS / BFS
│   └── Filtered traversal
│
├── Graph Algorithms
│   ├── Centrality (PageRank, Degree, Betweenness, Closeness)
│   ├── Community Detection (Louvain, Leiden, Label Propagation)
│   ├── Path Finding (Dijkstra, A*, BFS, DFS)
│   └── Similarity (Node Similarity, KNN, Jaccard, Cosine)
│
├── Graph Analytics Use Cases
│   ├── Social network analysis
│   ├── Sample Cypher queries
│   │   ├── Create user
│   │   ├── Create friendship
│   │   ├── Find friends
│   │   ├── Find posts
│   │   ├── Add tag
│   │   ├── Find popular posts
│   │   └── Friend recommendations
│   └── Key insights
│
└── Neo4j Architecture
    ├── Architecture layers
    ├── Property graph data model
    ├── Nodes
    ├── Relationships
    ├── Labels and properties
    └── Graph traversal in Neo4j

12. Key Syntax — Quick ReferenceCopy Anchor Link

13. Exam-Focused PointsCopy Anchor Link

1. Graph database — Stores data as nodes, relationships, properties.
2. Node — Entity; has label and properties.
3. Relationship — Connection between nodes; directed; has type.
4. Property — Key-value pair storing details.
5. Relational vs Graph — Tables vs connected entities.
6. Property graph model — Nodes + relationships + properties + labels.
7. Label — Type/category of a node.
8. Relationship type — Nature of connection (FRIEND_OF, WORKS_AT).
9. Cypher — Query language for Neo4j.
10. CREATE — Always creates new data.
11. MERGE — Creates only if not exists.
12. CREATE vs MERGE — Duplicates vs uniqueness.
13. Graph traversal — Navigating through relationships.
14. One-hop traversal — Direct neighbors.
15. Two-hop traversal — Nodes two steps away.
16. Variable-length traversal — [:FOLLOWS*1..3].
17. Shortest path — shortestPath().
18. DFS — Depth-first; explores branch.
19. BFS — Breadth-first; level by level.
20. Centrality algorithms — PageRank, Degree, Betweenness, Closeness.
21. PageRank — Importance based on incoming links.
22. Community detection — Louvain, Leiden.
23. Path finding — Dijkstra, A*, BFS, DFS.
24. Similarity — Node similarity, KNN, Jaccard, Cosine.
25. Neo4j — Native graph database.
26. Neo4j architecture — Applications → Cypher → Engine → Storage.
27. Neo4j storage — Nodes, relationships, labels, properties.
28. Indexes — On labels and properties for faster search.
29. Social network use case — Friends, posts, likes, tags.
30. Friend recommendations — Friends-of-friends query.

14. Glossary of Key TermsCopy Anchor Link