Shep’s Neo4j Cypher Query Cheatsheet

📝 What is Neo4j and Cypher?

Neo4j is a graph database that stores data in nodes and relationships rather than tables. This structure is perfect for highly connected data where relationships are as important as the data itself.

If you've ever diagrammed an idea with circles and arrows on a whiteboard, congratulations – you're thinking like a graph database!

Cypher is Neo4j's query language designed to be visually intuitive. Its ASCII-art style syntax resembles the graph patterns you're searching for:

• Nodes: (n:Person {name: "Alice"}) - Entities with labels and properties
• Relationships: -[:FRIENDS_WITH]-> - Directed connections between nodes
• Patterns: (a)-[:FRIENDS_WITH]->(b) - How data is connected

Why use a graph database?

• Perfect for highly connected data (social networks, recommendation engines, fraud detection)
• Relationships are first-class citizens, not afterthoughts
• Complex queries that would require multiple joins in SQL can be simpler and faster
• Flexible schema that can evolve as your application needs change

🔌 Connection & Database Management

For beginners, getting started with Neo4j involves setting up a connection to the database. Think of this as opening the door to your graph data.

Neo4j Desktop provides a graphical interface to manage your databases, but it's useful to understand these Cypher commands for connections, especially when working in production environments or with remote databases.

Query	Description
:CONNECT <bolt://localhost:7687> USER <username> PASSWORD <password>	Connect to a Neo4j database
SHOW DATABASES;	List all available databases
CREATE DATABASE <database-name>;	Create a new database (requires admin privileges)
USE <database-name>;	Switch to a specific database

💡 Beginner Tip: When you first install Neo4j, it creates a default database called "neo4j". The standard port is 7687, and the default credentials are username "neo4j" with password "neo4j" (you'll be asked to change this on first login).

🔷 Working with Nodes

Nodes are the fundamental entities in your graph - they represent the "things" in your data domain. Think of nodes as the nouns in a sentence.

In a social network, nodes might be people. In a movie database, nodes could be movies, actors, and directors. In a fraud detection system, nodes might be accounts, transactions, and users.

Nodes always have:

1. A unique internal ID (managed by Neo4j)
2. Zero or more labels (categories that nodes belong to)
3. Zero or more properties (key-value pairs of data)

Alice
:Person

Query	Description
CREATE (n:Person {name: "Alice", age: 30});	Create a single node with properties
MATCH (n:Person {name: "Alice"}) RETURN n;	Find a specific node
MATCH (n:Person) RETURN n;	Return all nodes with a specific label
MATCH (n) RETURN n;	Return all nodes in the database
MATCH (n:Person {name: "Alice"}) DELETE n;	Delete a specific node (fails if node has relationships)
MATCH (n:Person {name: "Alice"}) DETACH DELETE n;	Delete a node and all its relationships

💡 Understanding Node Syntax:
• (n): Parentheses represent a node, with "n" being a variable name you choose
• :Person: The label (like a table name in SQL)
• {name: "Alice", age: 30}: Properties stored on the node (key-value pairs)
• You can add multiple labels to a node: (n:Person:Employee)

↔️ Working with Relationships

Relationships are the connections between nodes - they represent how entities interact or relate to each other. Think of relationships as the verbs in a sentence.

What makes graph databases powerful is that relationships:

1. Always have a direction (though you can query in either direction)
2. Always have exactly one type (like FRIENDS_WITH or WORKS_AT)
3. Can have properties, just like nodes
4. Connect exactly two nodes (a start node and an end node)

The syntax for relationships uses arrows to show direction: -[r:RELATIONSHIP_TYPE]->

The ability to model and query complex relationships directly is what sets graph databases apart from traditional relational databases.

Alice
:Person

FRIENDS_WITH

Bob
:Person

Query	Description
MATCH (a:Person {name: "Alice"}), (b:Person {name: "Bob"}) CREATE (a)-[:FRIENDS_WITH]->(b);	Create a relationship between existing nodes
CREATE (a:Person {name: "Charlie"})-[:WORKS_AT]->(c:Company {name: "Neo4j"});	Create nodes and relationship in one query
MATCH (a:Person)-[r:FRIENDS_WITH]->(b:Person) RETURN a, r, b;	Find relationships of a specific type
MATCH (a:Person)-[r]->(b) RETURN a, r, b;	Find all outgoing relationships
MATCH (a)-[r]-(b) RETURN a, r, b;	Find relationships in any direction

💡 Understanding Relationship Syntax:
• -[:FRIENDS_WITH]->: The arrows show relationship direction (who is friends with whom)
• [:FRIENDS_WITH]: The relationship type in square brackets
• -[r:FRIENDS_WITH {since: 2010}]->: Relationships can have properties too
• -[*1..3]->: Variable-length paths (1 to 3 hops)
• -[]->: Any relationship type
• -[r]-: Relationship in either direction (no arrow)

🔄 Updating Data

Unlike relational databases with rigid schemas, Neo4j allows for flexible data modeling. You can add new properties or labels to existing nodes without having to modify a schema or migrate data.

This flexibility is powerful but requires discipline - since there's no schema enforcement, you need to ensure consistency in your property names and data types yourself. Many teams implement application-level validation to maintain data quality.

The SET and REMOVE commands handle most updates in Cypher, similar to UPDATE in SQL but with more flexibility for adding properties and labels on the fly.

Query	Description
MATCH (n:Person {name: "Alice"}) SET n.age = 31;	Update an existing property
MATCH (n:Person {name: "Alice"}) SET n.city = "New York";	Add a new property to a node
MATCH (n:Person {name: "Alice"}) REMOVE n.city;	Remove a property from a node
MATCH (n:Person {name: "Alice"}) SET n:Employee;	Add an additional label to a node
MATCH (n:Person {name: "Alice"}) REMOVE n:Employee;	Remove a label from a node
MATCH (a:Person)-[r:FRIENDS_WITH]->(b:Person) SET r.since = 2010;	Add or update relationship property

💡 Updating Tips:
• Use SET to add or modify properties and labels
• Use REMOVE to delete properties and labels
• The SET command can also set multiple properties at once:
SET n = {name: "Alice", age: 31, city: "New York"} (replaces all properties)
• Or update selectively: SET n += {city: "New York", job: "Developer"} (adds/updates only these properties)

⚠️ Important: Unlike SQL, there's no automatic schema enforcement. You need to ensure consistency in your property names and types yourself.

🔍 Advanced Querying

Once you have data in your graph, the real power comes from querying it in sophisticated ways. Cypher's pattern matching syntax lets you express complex queries much more intuitively than SQL joins.

Cypher queries typically follow a pattern:

1. MATCH - Define what pattern of nodes and relationships you're looking for
2. WHERE - Filter those results based on properties (optional)
3. RETURN - Specify what data you want back
4. ORDER BY, LIMIT, etc. - Modify the result set (optional)

The major difference from SQL is that you're thinking in patterns of connections rather than joining tables. This often makes complex queries much more readable and performant.

Query	Description
MATCH (n:Person) RETURN n ORDER BY n.name;	Order results by a property
MATCH (n:Person) RETURN n ORDER BY n.age DESC LIMIT 5;	Order by age descending and limit results
MATCH (n:Person) WHERE n.age > 30 RETURN n;	Filter results with WHERE clause
MATCH (n:Person) RETURN COUNT(n);	Count nodes with a specific label
MATCH (a:Person)-[:FRIENDS_WITH]-(b:Person) RETURN a.name, COUNT(b) AS friendsCount;	Count relationships per node
MATCH (n:Person) RETURN AVG(n.age);	Calculate average of a property

💡 Query Structure:
A typical Cypher query follows this pattern, similar to SQL:
1. MATCH - Define the pattern to search for (like FROM in SQL)
2. WHERE - Add conditions to filter results (optional)
3. RETURN - Specify what to include in results
4. ORDER BY - Sort the results (optional)
5. LIMIT - Restrict number of results (optional)

Syntax Comparison with SQL:

SQL	Cypher
SELECT * FROM Person	MATCH (n:Person) RETURN n
SELECT * FROM Person WHERE age > 30	MATCH (n:Person) WHERE n.age > 30 RETURN n
SELECT COUNT(*) FROM Person	MATCH (n:Person) RETURN COUNT(n)
SELECT name, age FROM Person ORDER BY age DESC LIMIT 5	MATCH (n:Person) RETURN n.name, n.age ORDER BY n.age DESC LIMIT 5

🌿 Path Finding

Path finding is where graph databases truly excel compared to relational databases. Finding routes, connections, or degrees of separation between entities is dramatically easier in a graph.

Some common path-finding use cases:

• Recommendation engines ("people who bought X also bought Y")
• Fraud detection (finding suspicious connection patterns)
• Supply chain analysis (tracking dependencies)
• Social network analysis (degrees of separation)
• Route optimization (shortest path algorithms)

Neo4j has built-in functions like shortestPath() that make these powerful queries simple to write. What might take dozens of lines of complex SQL can often be expressed in a single Cypher query.

Finding Paths in a Social Network

Alice → Charlie → Bob

Query	Description
MATCH p=(a:Person {name: "Alice"})-[:FRIENDS_WITH*1..3]->(b) RETURN p;	Find paths of length 1 to 3
MATCH p=shortestPath((a:Person {name: "Alice"})-[:FRIENDS_WITH*]-(b:Person {name: "Bob"})) RETURN p;	Find shortest path between nodes
MATCH (a:Person {name: "Alice"})-[:FRIENDS_WITH]-(commonFriend)-[:FRIENDS_WITH]-(b:Person {name: "Bob"}) RETURN commonFriend;	Find mutual friends (common neighbors)
MATCH (a:Person)-[:FRIENDS_WITH]->(b:Person)-[:FRIENDS_WITH]->(c:Person) WHERE a.name = "Alice" AND NOT (a)-[:FRIENDS_WITH]->(c) RETURN c;	Find friends-of-friends who aren't direct friends

💡 Path Finding Concepts:
• -[:RELATIONSHIP*1..3]->: The asterisk with numbers defines a variable-length path (1 to 3 hops)
• -[:RELATIONSHIP*]->: Any number of hops (use with caution on large graphs)
• shortestPath(): Built-in algorithm to find the shortest path between two nodes
• p=: Captures the entire path in a variable so you can return it
• Path finding is a killer feature of graph databases - these queries would be very complex in SQL

⚠️ Performance Warning: Unbounded path queries (like * without limits) can be very expensive on large graphs. Always try to limit the depth of your path queiries.

🚀 Performance Optimization

As your graph grows, query performance becomes important. Neo4j offers several tools to optimize performance:

1. Indexes: Just like in relational databases, indexes speed up property lookups
2. Query profiling: The PROFILE and EXPLAIN commands help you understand how queries execute
3. Query tuning: Techniques like specifying node labels and limiting result sets can dramatically improve performance

Graph databases shine with highly connected data, but they still require thoughtful query design for optimal performance, especially as your dataset grows to millions of nodes and relationships.

Query	Description
CREATE INDEX FOR (n:Person) ON (n.name);	Create an index on a property
DROP INDEX FOR (n:Person) ON (n.name);	Remove an index
EXPLAIN MATCH (n:Person {name: "Alice"}) RETURN n;	View execution plan without running query
PROFILE MATCH (n:Person {name: "Alice"}) RETURN n;	Run query and see detailed execution metrics
CALL db.schema.visualization();	Visualize database schema (labels and relationship types)
CALL db.indexes();	List all indexes in the database

🧩 Common Patterns & Examples

When learning Cypher, it helps to see practical examples of common operations. These patterns serve as building blocks you can combine and adapt for your specific use cases.

Many real-world graph applications combine these patterns to solve complex problems like:

• Recommendation engines
• Network and IT operations
• Fraud detection
• Identity and access management
• Master data management
• Knowledge graphs

As you get comfortable with these basic patterns, you can build up to more sophisticated queries that leverage the full power of graph databases.

Use Case	Query
Graph cleanup	MATCH (n) DETACH DELETE n;
Node existence check	MATCH (n:Person {name: "Alice"}) RETURN COUNT(n) > 0 AS exists;
Conditional creation	MERGE (n:Person {name: "Alice"}) ON CREATE SET n.created = timestamp();
Property collection	MATCH (n:Person) RETURN COLLECT(n.name) AS names;
Dynamic relationship traversal	MATCH (a:Person {name: "Alice"})-[r]->(b) RETURN type(r), b;
Aggregation by type	MATCH (n:Person) RETURN n.city, COUNT(n) AS people ORDER BY people DESC;

🎯 Pro Tips

Beyond the basic syntax, these pro tips will help you write better Cypher queries and work more efficiently with Neo4j:

When writing Cypher queries, think visually about the patterns you're trying to match. The ASCII-art style syntax ((a)-[:RELATES_TO]->(b)) is designed to look like the graph patterns you're searching for.

Start simple and build up complexity gradually. Test each part of your query to make sure it's returning what you expect before adding more complexity.

1. Use parameters - Instead of hardcoding values, use parameters like {name: $name} for better performance and security
2. Use EXPLAIN and PROFILE - Analyze your queries to identify performance bottlenecks
3. Create indexes early - Add indexes for properties you'll frequently query to improve performance
4. Use MERGE carefully - MERGE is powerful but can be expensive; use it only when necessary
5. Mind your memory - Large result sets can consume significant memory; use LIMIT when appropriate
6. Use LOAD CSV for imports - For bulk data imports, LOAD CSV is often more efficient than individual CREATEs
7. Be specific with patterns - Use node labels in your patterns to help the query planner optimize execution

And there you have it! Thanks for reading my Neo4j Cypher cheatsheet. Hope you found it helpful :)