Introduction to NoSQL(4360704) ER NO:216010307044

PRACTICAL NO: 07

Aim: Basic Graph Queries and Implementations with Neo4j

Objective
Students will acquire expertise in the Query Language, enabling them to execute fundamental
graph operations, explore graph algorithms and their applications. The practical will additionally
cover Neo4j optimization techniques and real-world graph database scenarios, enhancing students'
skills in graph querying and implementations.
Prerequisite Theory
Query Language
is Neo4j’s graph query language that lets you retrieve data from the graph. It is like SQL for graphs,
and was inspired by SQL so it lets you focus on what data you want out of the graph (not how to go
get it). It is the easiest graph language to learn by far because of its similarity to other languages
and intuitiveness.
is unique because it provides a visual way of matching patterns and relationships. was inspired by
an ASCII-art type of syntax where (nodes)- [:ARE_CONNECTED_TO]->(otherNodes) using rounded
brackets for circular (nodes), and - [:ARROWS]-> for relationships. When you write a query, you
draw a graph pattern through your data.
Neo4j users use to construct expressive and efficient queries to do any kind of create, read, update,
or delete (CRUD) on their graph, and is the primary interface for Neo4j.

A Y Dadabhai Technical Institute, Kosamba Page 1

Introduction to NoSQL(4360704) ER NO:216010307044
Once you start neo4j, you can use the :play command inside of Neo4j Browser to get
started.

Neo4j’s developer pages cover the basics of the language, which you can explore by
topic area below, starting with basic material, and building up towards more complex
material.
provides first class support for a number of data types. These fall into several
categories which will be described in detail in the following subsections:
Property types: Integer, Float, String, Boolean, Point, Date, Time, LocalTime,
DateTime, LocalDateTime, and Duration.
Structural types: Node, Relationship, and Path. Composite types: List and Map
In , comments are added by starting a line with // and writing text after the slashes.
Using two forward slashes designates the entire line as a comment, explaining syntax
or query functionality.
In , representing nodes involves enclosing them in parentheses, mirroring the visual
representation of circles used for nodes in the graph model. Nodes, which signify data
entities, are identified by finding nouns or objects in the data model. For instance, in
the example (Sally), (John), (Graphs), and (Neo4j) are nodes.

A Y Dadabhai Technical Institute, Kosamba Page 2

 Introduction to NoSQL(4360704) ER NO:216010307044

(1) Node Variables:

Nodes in can be assigned variables, such as (p) for person or (t) for thing.
These variables function similarly to programming language variables, allowing you
to reference the nodes by the assigned name later in the query.
(2) Node Labels:
Node labels in , similar to tags in the property graph data model, help group
similar nodes together. Labels, like Person, Technology, and Company, act as
identifiers, aiding in specifying certain types of entities to look for or create. Using
node labels in queries helps optimize execution and distinguish between different
entities.
( ) //anonymous node (no label or variable) can refer to any node in the
database
(p:Person) //using variable p and label Person
(:Technology) //no variable, label Technology
(work:Company) //using variable work and label Company
In , relationships are denoted by arrows (--> or <--) between nodes, resembling
the
visual representation of connecting lines. Relationship types and properties
can be specified in square brackets within the arrow. Directed relationships use
arrows, while undirected relationships use double dashes (--), allowing flexible
traversal in either direction without specifying the physical orientation in queries.
//data stored with this direction
CREATE (p:Person)-[:LIKES]->(t:Technology)
//query relationship backwards will not return results MATCH
(p:Person)<-[:LIKES]-(t:Technology)
//better to query with undirected relationship unless sure of direction
MATCH (p:Person)-[:LIKES]-(t:Technology)

(1) Relationship Types:

Relationship types in categorize connections between nodes, providing
meaning to the relationships similar to how labels group nodes. Good naming
conventions using verbs or actions are recommended for clarity and readability in
queries.
(2) Relationship Variables:
Like nodes, relationships in can be assigned variables such as [r] or [rel]. These
variables, whether short or expressive like [likes] or [knows], allow referencing the
relationship later in a query. Anonymous relationships can be specified with two
dashes (--, -->, <--) if they are not needed for reference.
In , node and relationship properties are represented using curly braces within
the parentheses for nodes and brackets for relationships. For example, a node
property is expressed as `(p:Person {name: 'Sally'})`, and a relationship property is
denoted as `- [rel:IS_FRIENDS_WITH {since: 2018}]->`.

A Y Dadabhai Technical Institute, Kosamba Page 3

Introduction to NoSQL(4360704) ER NO:216010307044

In , patterns are composed of nodes and relationships, expressing the

fundamental structure of graph data. Patterns can range from simple to intricate, and
in , they are articulated by combining node and relationship syntax, such as
`(p:Person {name: "Sally"})- [rel:LIKES]->(g:Technology {type: "Graphs"})`.
Creating Data with CREATE Clause:
In , the `CREATE` clause is used to add data by specifying patterns representing
graph structures, labels, and properties. For example, `CREATE (:Movie {title: 'The
Matrix', released: 1997})` creates a movie node with specified properties.

A Y Dadabhai Technical Institute, Kosamba Page 4

Introduction to NoSQL(4360704) ER NO:216010307044

To return created data, the `RETURN` clause is added, referencing variables

assigned to pattern elements. For instance, `CREATE (p:Person {name: 'Keanu
Reeves'}) RETURN p` creates a person node and returns it in the result.
Matching Patterns with MATCH Clause:
The `MATCH` clause is used for finding patterns in the graph. It enables
specifying patterns similar to `CREATE` but focuses on identifying existing data. For
example, `MATCH (m:Movie) RETURN m` finds all movie nodes.

The `MERGE` clause combines elements of `MATCH` and `CREATE`, ensuring

uniqueness by checking for existing data before creating. It's useful for creating or
matching nodes and relationships. For instance, `MERGE (m:Movie {title: 'Cloud
Atlas'}) ON CREATE SET m.released = 2012 RETURN m` merges or creates a movie
node and returns it.
Return values can be aliased for better readability using the `AS` keyword. For
example,
`RETURN tom.name AS name, tom.born AS 'Year Born'` provides cleaner and
more informative result labels.
Filtering results
Explore result refinement in by using the WHERE clause to filter and retrieve
specific subsets of data based on boolean expressions, predicates, and comparisons,
including logical operators like AND, OR, XOR, and NOT.
MATCH (m:Movie)
WHERE m.title = 'The Matrix'
RETURN m

A Y Dadabhai Technical Institute, Kosamba Page 5

Introduction to NoSQL(4360704) ER NO:216010307044

(1) Inserting Data:

Use the `CREATE` keyword to add nodes and relationships to Neo4j.
Patterns can be created blindly, but using `MATCH` before `CREATE` ensures
uniqueness.
CREATE (j:Person {name: 'Jennifer'})-[rel:IS_FRIENDS_WITH]->(m:Person
{name: 'Mark'})
(2) Updating Data:
Modify node properties using `SET` after a `MATCH` statement.
Update relationship properties similarly by specifying the relationship in the
`MATCH` clause.
MATCH (p:Person {name: 'Jennifer'})
SET p.birthdate = date('1980-01-01')
RETURN p
(3) Deleting Data:
Delete relationships with `DELETE` after a `MATCH` specifying the relationship.
Delete nodes without relationships using `DELETE` after a `MATCH` specifying
the node.
Use `DETACH DELETE` to delete a node along with its relationships.
(4) Deleting Properties:
Remove properties using `REMOVE` or set them to `null` with `SET` for nodes.
//delete property using REMOVE keyword MATCH (n:Person {name:
'Jennifer'}) REMOVE n.birthdate
//delete property with SET to null value MATCH (n:Person {name:
'Jennifer'}) SET n.birthdate = null

(5) Avoiding Duplicate Data with MERGE:

Use `MERGE` to perform a "select-or-insert" operation for nodes and
relationships.
`MERGE` checks for the entire pattern's existence and creates it if not found.
MERGE (mark:Person {name: 'Mark'})
RETURN mark

(6) Handling MERGE Criteria:

Utilize `ON CREATE SET` and `ON MATCH SET` to specify actions during node
or relationship creation or matching.
This helps initialize properties when creating and update properties when
matching.
MATCH (j:Person {name: 'Jennifer'})
MATCH (m:Person {name: 'Mark'})
MERGE (j)-[r:IS_FRIENDS_WITH]->(m)
RETURN j, r, m
A Y Dadabhai Technical Institute, Kosamba Page 6
Introduction to NoSQL(4360704) ER NO:216010307044

GRAPH ALGORITHMS AND THEIR APPLICATIONS

Graph algorithms provide one of the most potent approaches to analyzing
connected data because their mathematical calculations are specifically built to
operate on relationships. They describe steps to be taken to process a graph to
discover its general qualities or specific quantities.
The library contains implementations for the following types of algorithms:
• Path Finding - these algorithms help find the shortest path or evaluate the
availability and quality of routes
• Centrality - these algorithms determine the importance of distinct nodes in a
network
• Community Detection - these algorithms evaluate how a group is clustered or
partitioned, as well as its tendency to strengthen or break apart
• Similarity - these algorithms help calculate the similarity of nodes
• Topological link prediction - these algorithms determine the closeness of pairs
of nodes
• Node Embeddings - these algorithms compute vector representations of nodes
in a graph.
• Node Classification - this algorithm uses machine learning to predict the
classification of nodes.
• Link prediction - these algorithms use machine learning to predict new links
between pairs of nodes
Neo4j optimization techniques Memory Configuration Guidelines:
OS Memory Sizing:
- Reserve around 1GB for non-Neo4j server activities.
- Avoid exceeding available RAM to prevent OS swapping, which impacts
performance.
Page Cache Sizing:
- Utilize the page cache to cache Neo4j data stored on disk.
- Estimate page cache size by summing the sizes of relevant database files
and adding a growth factor.
- Configure the page cache size in `neo4j.conf` (default is 50% of available
RAM).
Heap Sizing:
- Configure a sufficiently large heap space for concurrent operations (8G to
16G is often adequate).
- Adjust heap size using parameters
`dbms.memory.heap.initial_size` and
`dbms.memory.heap.max_size` in `neo4j.conf`.
- Set these parameters to the same size for optimal performance.
*(Refer to the Neo4j Operations Manual for detailed discussions on heap
memory configuration, distribution, and garbage collection tuning.)*

A Y Dadabhai Technical Institute, Kosamba Page 7

Introduction to NoSQL(4360704) ER NO:216010307044

Logical Logs:
- Logical transaction logs are crucial for recovery after an unclean shutdown and
incremental backups.
- Log files are rotated after reaching a specified size (e.g., 25 MB).
- Configure log retention policy using the `dbms.tx_log.rotation.retention_policy`
parameter (recommended: 7 days).
Number of Open Files:
- The default open file limit of 1024 may be insufficient, especially with multiple
indexes or high connection volumes.
- Increase the limit to a practical value (e.g., 40000) based on usage patterns.
- Adjust system-wide open file limit following platform-specific instructions
(ulimit command for current session).
Real-world graph database scenarios
Example #1: Using Neo4j to determine customer preferences
Suppose we need to learn preferences of our customers to create a promotional
offer for a specific product category, such as notebooks. First, Neo4j allows us to
quickly obtain a list of notebooks that customers have viewed or added to their wish
lists. We can use this code to select all such notebooks:
MATCH (:Customer)- [:ADDED_TO_WISH_LIST|:VIEWED] - >
(notebook:Product) - [:IS_IN]->(:Category {title: 'Notebooks'})
RETURN notebook;
Now that we have a list of notebooks, we can easily include them in a
promotional offer. Let’s make a few modifications to the code above:
CREATE(offer:PromotionalOffer {type: 'discount_offer', content:
'Notebooks discount offer...'})
WITH offer
MATCH (:Customer)-[:ADDED_TO_WISH_LIST|:VIEWED]-
>(notebook:Product)- [:IS_IN]->(:Category {title: 'Notebooks'})
MERGE(offer)-[:USED_TO_PROMOTE]->(notebook);

A Y Dadabhai Technical Institute, Kosamba Page 8

 Introduction to NoSQL(4360704) ER NO:216010307044

We can track the changes in the graph with the following query:
MATCH (offer:PromotionalOffer)- [:USED_TO_PROMOTE]- (product:Product)
RETURN offer, product;

Linking a promotional offer with specific customers makes no sense, as the structure of graphs
allows you to access any node easily. We can collect emails for a newsletter by analyzing the
products in our promotional offer.
When creating a promotional offer, it’s important to know what products customers have viewed or
added to their wish lists. We can find out with this query:
MATCH (offer:PromotionalOffer {type: 'discount_offer'})-
[:USED_TO_PROMOTE]-
>(product:Product)<-[:ADDED_TO_WISH_LIST|:VIEWED]-
(customer:Customer)
RETURN offer, product, customer;

A Y Dadabhai Technical Institute, Kosamba Page 9

 Introduction to NoSQL(4360704) ER NO:216010307044

This example is simple, and we could have implemented the same functionality
in a relational database. But our goal is to show the intuitiveness of and to
demonstrate how simple it is to write queries in Neo4j.
Example #2: Using Neo4j to devise promotional offers
Now let’s imagine that we need to develop a more efficient promotional
campaign. To increase conversion rates, we should offer alternative products to our
customers. For example, if a customer shows interest in a certain product but doesn’t
buy it, we can create a promotional offer that contains alternative products.
To show how this works, let’s create a promotional offer for a specific
customer:
MATCH (alex:Customer {name: 'Alex McGyver'}) MATCH (free_product:Product)
WHERE NOT ((alex)-->(free_product)) MATCH (product:Product)
WHERE ((alex)-->(product))
MATCH (free_product)-[:IS_IN]->()<-[:IS_IN]-(product)
WHERE ((product.price - product.price * 0.20) >= free_product.price <=
(product.price + product.price * 0.20))
RETURN free_product;
This query searches for products that don’t have either ADDED_TO_WISH_LIST,
VIEWED, or BOUGHT relationships with a client named Alex McGyver. Next, we perform an
opposite query that finds all products that Alex McGyver has viewed, added to his wish list,
or bought. Also, it’s crucial to narrow down recommendations, so we should make sure that
these two queries select products in the same categories. Finally, we specify that only
products that cost 20 percent more or less than a specific item should be recommended to
the customer.
Now let’s check if this query works correctly.
The product variable is supposed to contain the following items:
Xiaomi Mi Mix 2 (price: $420.87). Price range for recommendations: from $336.70 to
$505.04. Sony Xperia XA1 Dual G3112 (price: $229.50). Price range for recommendations:
from
$183.60 to $275.40.
The free_product variable is expected to have these items:
Apple iPhone 8 Plus 64GB (price: $874.20) Huawei P8 Lite (price: $191.00)
Samsung Galaxy S8 (price: $784.00) Sony Xperia Z22 (price: $765.00)
Note that both product and free_product variables contain items that belong to the
same category, which means that the [:IS_IN]->()<-[:IS_IN] constraint has worked.
As you can see, none of the products except for the Huawei P8 Lite fits in the price
range for recommendations, so only the P8 Lite will be shown on the recommendations list
after the query is executed.
Now we can create our promotional offer. It’s going to be different from the previous
one (personal_replacement_offer instead of discount_offer), and this time we’re going to
store a customer’s email as a property of the USED_TO_PROMOTE relationship as the
products contained in the free_product variable aren’t connected to specific customers.
Here’s the full code for the promotional offer:

A Y Dadabhai Technical Institute, Kosamba Page 10

 Introduction to NoSQL(4360704) ER NO:216010307044

MATCH (alex:Customer {name: 'Alex McGyver'})

MATCH (free_product:Product) WHERE NOT ((alex)-->(free_product))
MATCH (product:Product)
WHERE ((alex)-->(product))
MATCH (free_product)-[:IS_IN]->()<-[:IS_IN]-(product)
WHERE ((product.price - product.price * 0.20) >= free_product.price <=
(product.price +
product.price * 0.20))
CREATE(offer:PromotionalOffer {type:
'personal_replacement_offer', content: 'Personal
replacement offer for ‘ + alex.name})
WITH offer, free_product, alex
MERGE(offer)-[rel:USED_TO_PROMOTE {email: alex.email}]-
>(free_product) RETURN offer, free_product, rel;

Let’s take a look at the result of this query:

• In the form of a graph
• In the form of a table

A Y Dadabhai Technical Institute, Kosamba Page 11

 Introduction to NoSQL(4360704) ER NO:216010307044

Example #3: Building a recommendation system with Neo4j

The Neo4j database proves useful for building a recommendation system.
Imagine we want to recommend products to Alex McGyver according to his interests.
Neo4j allows us to easily track the products Alex is interested in and find other customers
who also have expressed interest in these products. Afterward, we can check out these
customers’ preferences and suggest new products to Alex.
First, let’s take a look at all customers and the products they’ve viewed, added to
their wish lists, and bought:
MATCH (customer:Customer)-->(product:Product)
RETURN customer, product;

A Y Dadabhai Technical Institute, Kosamba Page 12

Introduction to NoSQL(4360704) ER NO:216010307044

As you can see, Alex has two touch points with other customers: the Sony Xperia XA1
Dual G3112 (purchased by Allison York) and the Nikon D7500 Kit 18–105mm VR (viewed
by Joe Baxton). Therefore, in this particular case, our product recommendation system
should offer to Alex those products that Allison and Joe are interested in (but not the
products Alex is also interested in). We can implement this simple recommendation system
with the help of the following query:
MATCH (:Customer {name: 'Alex McGyver'})-->(product:Product)<--
(customer:Customer)
MATCH (customer)-->(customer_product:Product)
WHERE (customer_product <> product)
RETURN customer, customer_product;

We can further improve this recommendation system by adding new conditions, but the
takeaway is that Neo4j helps you build such systems quickly and easily.

A Y Dadabhai Technical Institute, Kosamba Page 13

Introduction to NoSQL(4360704) ER NO:216010307044

Practical related Questions

Multiple-Choice Questions (MCQ):
(1) What does the MATCH clause in do? (
(a) Create nodes and relationships. (b) Find patterns in the graph.
(c) Update existing data. (d) Delete nodes.
Ans:

(2) How do you create a new node with a label in ?

(a) INSERT (c) ADD
(b) CREATE (d) NODE
3. Which clause is used to filter query results based on specified conditions?
(a) CREATE (c) MATCH
(b) FILTER (d) WHERE
4. What is the purpose of the RETURN clause in ?
(a) Create new nodes. (b) Filter query results.
(c) Return specified data from the query. (d) Delete nodes.
5. How do you add a property to an existing node in ?
(a) SET (c)MODIFY
(b) ADD (d) UPDATE
6. What does the MERGE clause do in ?
(a) Deletes nodes and relationships.
(b) Creates new nodes and relationships.
(c) Matches patterns if they exist, otherwise creates them.
(d) Filters query results based on conditions.
True/False Questions:

(1) In , the WHERE clause is used to specify conditions for filtering query results. (True/False)

Ans:

(2) The CREATE clause in is used to find patterns in the graph. (True/False)

Ans:

(3) 's DELETE clause is used exclusively for removing nodes from the graph.

(True/False)

Ans:

A Y Dadabhai Technical Institute, Kosamba Page 14

Introduction to NoSQL(4360704) ER NO:216010307044

Write queries for following :

QUERY: 1 Basic Graph Queries and Implementations with Neo4j
1. To add a new node representing a movie with the title "Inception" and release year
2010. Write a query to achieve this.
2. Retrieve the names of all actors who have acted in movies released after the year
2000. Write a query for this.
3. Change the release year of the movie "The Matrix" to 1999. Write a query to
update this information.
4. Delete a relationship between a person node (representing a user) and a movie node
(representing a favorite movie). Write a query to perform this deletion.
5. Retrieve the names of directors who directed movies with a rating higher than 8. Write
a query with the WHERE clause.
6. Create a new node representing an actor named "Tom Hanks" and assign the label
"Actor" to the node. Write a query for this.
7. Find all pairs of actors who have acted together in the same movie. Write a
query to retrieve this information.
8. Retrieve the names of users who have rated a movie with a rating greater than 4.
Write a query with the MATCH and RETURN clauses.
9. Connect a person node representing "Alice" to a movie node representing "The
Shawshank Redemption" with a relationship indicating that Alice has rated the movie.
Write a query for this.
10 Retrieve the titles of movies released between 2010 and 2020. Write a query
with conditional operators.

A Y Dadabhai Technical Institute, Kosamba Page 15

 Introduction to NoSQL(4360704) ER NO:216010307044
Here are the queries for the tasks you described:

1. Add a new movie node:

CREATE (m:Movie {title: "Inception", releaseYear: 2010})

This query creates a new node with the label Movie and sets its properties title to "Inception" and
releaseYear to 2010.

2. Find actors in movies after 2000:

MATCH (a:Actor)-[:ACTED_IN]->(m:Movie)
WHERE m.releaseYear > 2000
RETURN a.name

This query matches relationships between Actor and Movie nodes where the releaseYear property
of the Movie node is greater than 2000. It then returns the name property of the Actor nodes.

3. Update movie release year:

MATCH (m:Movie {title: "The Matrix"})

SET m.releaseYear = 1999

This query matches the Movie node with the title "The Matrix" and updates its releaseYear property
to 1999.

4. Delete user-favorite movie relationship:

MATCH (p:Person)-[r:RATED]->(m:Movie)
DELETE r

This query matches any relationship (r) with the type RATED between a Person and Movie node. It
then deletes the matched relationship.

5. Find directors of high-rated movies:

MATCH (d:Director)-[:DIRECTED]->(m:Movie)
WHERE m.rating > 8
RETURN d.name

This query matches relationships between Director and Movie nodes where the rating property of
the Movie node is greater than 8. It then returns the name property of the Director nodes.

6. Create a new actor node:

CREATE (a:Actor {name: "Tom Hanks"})

This query creates a new node with the label Actor and sets its name property to "Tom Hanks".

7. Find actors who acted together:

A Y Dadabhai Technical Institute, Kosamba Page 16
 Introduction to NoSQL(4360704) ER NO:216010307044
MATCH (a1:Actor)-[:ACTED_IN]->(m:Movie)<-[:ACTED_IN]-(a2:Actor)
WHERE a1.name <> a2.name
RETURN a1.name, a2.name

This query finds relationships between two Actor nodes connected through the same Movie node. It
excludes actors who acted in the same movie alone (a1.name <> a2.name) and returns their names.

8. Find users who rated movies above 4:

MATCH (u:Person)-[:RATED]->(m:Movie)
WHERE m.rating > 4
RETURN u.name

This query matches relationships between Person and Movie nodes with the type RATED where the
rating property of the Movie node is greater than 4. It then returns the name property of the Person
nodes.

9. Connect user to movie with a rating:

MATCH (p:Person {name: "Alice"}), (m:Movie {title: "The Shawshank Redemption"})

CREATE (p)-[:RATED]->(m)

This query matches a Person node with the name "Alice" and a Movie node with the title "The
Shawshank Redemption". It then creates a new relationship of type RATED between them.

10. Find movie titles from a specific release range:

MATCH (m:Movie)
WHERE m.releaseYear >= 2010 AND m.releaseYear <= 2020
RETURN m.title

These queries should help you perform various operations and retrieve specific information from
your Neo4j graph database. Adjust them as needed based on your data model and requirements.

A Y Dadabhai Technical Institute, Kosamba Page 17

Introduction to NoSQL(4360704) ER NO:216010307044

ASSESSMENT RUBRICS
Needs
Criteria Excellent (10) Good (7) Satisfactory (5) Marks
Improvement
(3)
Shows a high
Mastery of Demonstrates Demonstrates Struggles with
level of
Query exceptional basic proficiency queriesand
proficiency in
Language proficiency in in queries lacks
queries
queries proficiency

Executes basic Performs Struggles to

Execution of Carries out basic
graph basic graph execute basic
Basic Graph graph operations
operations operations graph operations
Operations but with some
withprecision with or makes
errors
and accuracy competence significant errors
Struggles to use
Utilization of Effectively Uses Neo4j Attempts to use
Neo4j
Neo4j utilizes Neo4j optimizatio Neo4j
optimization
Optimization optimization ntechniques optimization
techniques or
Techniques techniques with some techniques but
lacks
success with limitations
understanding
Handling Successfully Handles real- Struggles to
Attempts to
Real-World handles real- world handle real-world
handle real-world
Graph world graph scenarios with scenarios or
scenarios but
Database database reasonable encounters
with limitations
Scenarios scenarios success significant issues
Average Marks

------------
Signature with date

A Y Dadabhai Technical Institute, Kosamba Page 18