Software Development

Querying Graphs with Neo4j Cheatsheet

1. Introduction to Neo4j

Neo4j is a leading graph database management system that enables efficient storage and Querying Graphs of connected data. It’s designed to work with highly interconnected data models, making it suitable for applications such as social networks, recommendation systems, fraud detection, and more.



Key Concepts:

NodesFundamental building blocks representing entities in the graph database’s domain.
RelationshipsConnections between nodes that convey meaningful information and context between the connected nodes.
PropertiesKey-value pairs attached to nodes and relationships for storing additional data or attributes.
Graph ModelingGraph databases employ a schema-less model that offers flexibility to adapt to changing data structures.

1.1 What is a Graph Database

A graph database is a specialized type of database designed to store and manage data using graph structures. In a graph database, data is modeled as nodes, relationships, and properties. It’s a way to represent and store complex relationships and connections between various entities in a more intuitive and efficient manner compared to traditional relational databases.

Graph databases offer several advantages, especially when dealing with highly interconnected data:

Advantages of Graph DatabasesDescription
Efficient Relationship HandlingGraph databases excel at traversing relationships efficiently. This makes them ideal for scenarios where understanding connections and relationships is a critical part of the data.
Flexible Data ModelingGraph databases adopt a schema-less approach, enabling easy adaptation of data models as requirements evolve. This adaptability is particularly beneficial for dynamic data structures.
Complex QueriesGraph databases excel at handling complex queries involving relationships and patterns. They can uncover hidden relationships and insights that might be challenging for traditional databases.
Use CasesGraph databases are well-suited for applications like social networks, recommendation systems, fraud detection, and knowledge graphs. They shine where relationships are as important as data.
Query PerformanceGraph databases generally offer superior query performance when retrieving related data, thanks to their optimized traversal mechanisms.
Natural RepresentationGraph databases provide a more natural way to model and represent real-world scenarios, aligning well with how humans perceive and understand relationships.

However, it’s important to note that while graph databases excel in certain use cases, they might not be the optimal choice for every type of application. Choosing the right database technology depends on the specific needs of your project, including data structure, query patterns, and performance requirements.

1.2 Cypher

Neo4j uses its own language for Querying Graphs called Cypher. Cypher is specifically designed for querying and manipulating graph data in the Neo4j database. It provides a powerful and expressive way to interact with the graph database, making it easier to work with nodes, relationships, and their properties.

Cypher is designed to be human-readable and closely resembles patterns in natural language when describing graph patterns. It allows you to express complex queries in a concise and intuitive manner. Cypher queries are written using ASCII art-like syntax to represent nodes, relationships, and patterns within the graph.

For example, a simple Cypher query to retrieve all nodes labeled as “Person” and their names might look like:

MATCH (p:Person)

In this query, MATCH is used to specify the pattern you’re looking for, (p:Person) defines a node labeled as “Person,” and RETURN specifies what information to retrieve.

Cypher also supports a wide range of functionalities beyond basic querying, including creating nodes and relationships, filtering, sorting, aggregating data, and more. It’s a central tool for interacting with Neo4j databases effectively and efficiently.

It’s important to note that while Cypher is specific to Neo4j, other graph databases might have their own query languages or might support other query languages like GraphQL, SPARQL, etc., depending on the database technology being used.

2. Getting Started

To begin using Neo4j for Querying Graphs, follow these steps:

2.1 Installing Neo4j

Download and install Neo4j from the official website. Choose the appropriate version based on your operating system. Follow the installation instructions for a smooth setup.

2.2 Accessing Neo4j Browser

Neo4j Browser is a web-based interface that allows you to interact with your graph database using Cypher queries. After installing Neo4j, you can access the browser by navigating to http://localhost:7474 in your web browser.

2.3 Creating a new graph database

Once you’re in Neo4j Browser, you can create a new graph database using Cypher. For example, to create a node with a “Person” label and a “name” property, run:

CREATE (:Person {name: 'John'})

3. Basic Data Retrieval

To retrieve data from your Neo4j database, you can use the MATCH clause along with patterns to specify what you’re looking for.

3.1 Retrieving nodes

To retrieve all nodes with a specific label, use the MATCH clause followed by the label:

MATCH (p:Person)

3.2 Retrieving relationships

To retrieve specific relationships between nodes, use the MATCH clause with the desired pattern:

MATCH (p1:Person)-[:FRIENDS_WITH]->(p2:Person)
RETURN p1, p2

3.3 Combining node and relationship retrieval

You can retrieve both nodes and relationships in a single query:

MATCH (p1:Person)-[r:FRIENDS_WITH]->(p2:Person)
RETURN p1, r, p2

4. Filtering and Sorting

Use the WHERE clause to filter query results based on specific conditions.

4.1 Using WHERE to filter nodes and relationships

Filter nodes based on property values:

MATCH (p:Person)
WHERE p.age > 30

4.2 Applying multiple conditions

Combine conditions using logical operators

MATCH (p:Person)
WHERE p.age > 30 AND p.location = 'New York'

4.3 Sorting query results

Use the ORDER BY clause to sort results:

MATCH (p:Person)

5. Aggregation and Grouping

Aggregation functions allow you to summarize and analyze data.


Aggregate functions work on numeric properties:

MATCH (p:Person)
RETURN COUNT(p) AS totalPeople, AVG(p.age) AS avgAge

5.2 GROUP BY clause

Group data based on specific properties:

MATCH (p:Person)
RETURN p.location, AVG(p.age) AS avgAge
GROUP BY p.location

5.3 Filtering aggregated results with HAVING

Filter groups using the HAVING clause

MATCH (p:Person)
RETURN p.location, AVG(p.age) AS avgAge
GROUP BY p.location
HAVING avgAge > 30

6. Advanced Relationship Traversal

Neo4j power of Querying Graphs lies in traversing complex relationships.

6.1 Traversing multiple relationships

Navigate through multiple relationships:

MATCH (p:Person)-[:FRIENDS_WITH]->(:Person)-[:LIKES]->(m:Movie)

6.2 Variable-length relationships

Use the asterisk (*) syntax for variable-length paths:

MATCH (p:Person)-[:FRIENDS_WITH*1..2]->(friend:Person)
RETURN p, friend

6.3 Controlling traversal direction

Specify traversal direction with arrow notation:

MATCH (p:Person)-[:FRIENDS_WITH]->(friend:Person)
RETURN p, friend

7. Pattern Matching with MATCH

Patterns allow you to specify the structure of your data.

7.1 Matching specific patterns

Match nodes and relationships based on patterns:

MATCH (p:Person)-[:FRIENDS_WITH]->(friend:Person)
WHERE = 'Alice'
RETURN friend

7.2 Optional match with OPTIONAL MATCH

Include optional relationships in the pattern:

MATCH (p:Person)
OPTIONAL MATCH (p)-[:LIKES]->(m:Movie)

7.3 Using patterns as placeholders

Use variables to match patterns conditionally:

MATCH (p:Person)-[:FRIENDS_WITH]->(friend:Person)
WITH friend, size((friend)-[:LIKES]->()) AS numLikes
WHERE numLikes > 2
RETURN friend

8. Working with Path Results

Paths represent sequences of nodes and relationships.

8.1 Returning paths in queries

Use the MATCH clause to return paths:

MATCH path = (p:Person)-[:FRIENDS_WITH]->(:Person)-[:LIKES]->(m:Movie)

8.2 Filtering paths based on conditions

Filter paths based on specific criteria:

MATCH path = (p:Person)-[:FRIENDS_WITH]->(friend:Person)
WHERE size((friend)-[:LIKES]->()) > 2

8.3 Limiting the number of paths

Use the LIMIT clause to restrict results:

MATCH path = (p:Person)-[:FRIENDS_WITH]->(:Person)-[:LIKES]->(m:Movie)

9. Modifying Data with CREATE, UPDATE, DELETE

Cypher allows you to create, update, and delete data.

9.1 Creating nodes and relationships

Use the CREATE clause to add nodes and relationships:

CREATE (p:Person {name: 'Eve', age: 28})

9.2 Updating property values

Use the SET clause to update properties:

MATCH (p:Person {name: 'Eve'})
SET p.age = 29

9.3 Deleting nodes, relationships, and properties

Use the DELETE clause to remove data:

MATCH (p:Person {name: 'Eve'})

10. Indexes and Constraints

Indexes and constraints enhance query performance and data integrity.

10.1 Creating indexes for faster querying

Create an index on a property for faster retrieval:

CREATE INDEX ON :Person(name)

10.2 Adding uniqueness constraints

Enforce uniqueness on properties:


10.3 Dropping indexes and constraints

Remove indexes and constraints as needed:

DROP INDEX ON :Person(name)

11. Combining Cypher Queries

Combine multiple queries for more complex operations.

11.1 Using WITH for result pipelining

Pass query results to the next part of the query:

MATCH (p:Person)
MATCH (p)-[:FRIENDS_WITH]->(friend:Person)
RETURN p, friend

11.2 Chaining multiple queries

Chain queries together using semicolons:

MATCH (p:Person)
MATCH (m:Movie)
RETURN m.title

11.3 Using subqueries

Embed subqueries within larger queries:

MATCH (p:Person)
WHERE p.age > (SELECT AVG(age) FROM Person)

12. Importing Data into Neo4j

Importing external data into Neo4j as graphs for querying is a common task.

12.1 Using Cypher’s LOAD CSV for CSV imports

Load data from CSV files into the graph:

LOAD CSV WITH HEADERS FROM 'file:///people.csv' AS row
CREATE (:Person {name:, age: toInteger(row.age)})

12.2 Integrating with ETL tools

Use ETL (Extract, Transform, Load) tools like Neo4j ETL or third-party tools to automate data imports.

12.3 Data Modeling Considerations

Plan your graph model and relationships before importing data to ensure optimal performance and queryability.

13. Performance Tuning

Optimize your queries for better performance.

13.1 Profiling queries for optimization

Use the PROFILE keyword to analyze query execution:

PROFILE MATCH (p:Person)-[:FRIENDS_WITH]->(:Person)

13.2 Understanding query execution plans

Analyze query plans to identify bottlenecks and optimizations.

Tips for improving query performance:

  • Use indexes for property-based filtering.
  • Avoid unnecessary traversals by using specific patterns.
  • Profile and analyze slow queries to identify improvements.

14. Working with Dates and Times

Store, query, and manipulate date and time values.

14.1 Storing and querying date/time values

Store date/time properties and query them using comparisons:

MATCH (p:Person)
WHERE p.birthdate > date('1990-01-01')

14.2 Performing date calculations

Perform calculations on date properties:

MATCH (p:Person)
SET p.age = date().year - p.birthdate.year

14.3 Handling time zones

Use the datetime() function to work with time zones:

MATCH (m:Movie)
SET m.releaseDate = datetime('2023-07-01T00:00:00Z')

15. User-Defined Procedures and Functions

Extend Cypher’s capabilities with user-defined procedures and functions.

15.1 Creating custom procedures and functions

Write custom procedures using Java and integrate them into your Cypher queries.

15.2 Loading and using APOC library

APOC (Awesome Procedures on Cypher) is a popular library of procedures and functions:

CALL'2023-07-01', 's', 'yyyy-MM-dd') YIELD value
RETURN value.year AS year

15.3 Extending Query Capabilities

User-defined functions allow you to encapsulate logic and reuse it in queries.

16. Exporting Query Results

Export query results for further analysis.

16.1 Exporting to CSV

Use the EXPORT CSV clause to export data to a CSV file:

MATCH (p:Person)
RETURN, p.age
EXPORT CSV WITH HEADERS FROM 'file:///people.csv'

16.2 JSON and other formats

For JSON export, use the APOC library:

CALL apoc.export.json.query("MATCH (p:Person) RETURN p", 'people.json', {})

17. Additional Resources

Neo4j DocumentationOfficial documentation for Neo4j, including guides, tutorials, and reference materials.
Neo4j Community ForumAn online community forum where you can ask questions, share knowledge, and engage with other Neo4j users.
Cypher Query Language ManualIn-depth guide to the Cypher query language, explaining its syntax, functions, and usage.
Graph Databases for BeginnersA beginner-friendly guide to graph databases, their benefits, and how they compare to other database types.
Neo4j Online TrainingPaid and free online courses provided by Neo4j to learn about graph databases and how to work with Neo4j effectively.
YouTube: Neo4j ChannelNeo4j’s official YouTube channel with video tutorials, webinars, and talks about graph databases and Neo4j features.
GitHub: Neo4j ExamplesRepository containing sample code and examples for various use cases, helping you understand practical applications of Neo4j.

Odysseas Mourtzoukos

Mourtzoukos Odysseas is studying to become a software engineer, at Harokopio University of Athens. Along with his studies, he is getting involved with different projects on gaming development and web applications. He is looking forward to sharing his knowledge and experience with the world.
Notify of

This site uses Akismet to reduce spam. Learn how your comment data is processed.

Inline Feedbacks
View all comments
Back to top button