Learn Cypher - the Neo4j query language

Intro
- Our example graph consists of movies with an id, year and title and actors with a name. Actors have an :ACTS_IN relationship to movies, which represents the role they played, the role relationship has also a role attribute.
- We encourage you to enter the Cypher statements in the interactive console manually, but you can also click on the code snippets.
  Like this one
```
START n=node(*) 
RETURN "Hello Graph with "+count(*)+" Nodes!" 
as welcome;
```

First steps with Cypher

return a single node, by id (The Matrix)

START movie=node:node_auto_index(id="603") 
RETURN movie;

return the title and id of the matrix node

START movie=node:node_auto_index(id="603")  
RETURN movie.id, movie.title;

first use of the MATCH clause, show all actors

START m=node:node_auto_index(id="603")  
MATCH m<-[:ACTS_IN]-actor 
RETURN actor;

return just the name, order them by name

START m=node:node_auto_index(id="603") 
MATCH m<-[:ACTS_IN]-actor 
RETURN actor.name order by actor.name;

first aggregation, count the actors

START m=node:node_auto_index(id="603") 
MATCH m<-[:ACTS_IN]-actor 
RETURN count(*);

first filtering only the actors whose names end with "s"

START m=node:node_auto_index(id="603")  
MATCH m<-[:ACTS_IN]-actor 
WHERE actor.name =~ ".*s$" 
RETURN actor.name ;

Explore a dataset
- some exploratory queries for unknown datasets, don’t do that on live production instances
- Count nodes
```
START n=node(*)  
RETURN count(*);
```
- Count relationship types
```
START n=node(*)  
MATCH n-[r]->() 
RETURN type(r), count(*);
```
- List all nodes and their relationships
```
START n=node(*)    
MATCH n-[r]->m 
RETURN n as from, r as `->`, m as to;
```

Updating the graph

we will add ourselves, friends and ratings
add a node for yourself and return it, let's say your name is "Me"
```
CREATE me={name: "Me"} RETURN me;
```

let's check if the node is there:

START me=node:node_auto_index(name="Me") RETURN me.name;

I want to rate a movie

START me=node:node_auto_index(name="Me"), movie=node:node_auto_index(id="603") 
CREATE me-[:RATED {stars : 5, comment : "I love that movie!"}]->movie;

which movies did I rate

START me=node:node_auto_index(name="Me") 
MATCH me-[r:RATED]->movie RETURN r.stars, r.comment,movie.title;

Updating the graph

we need a friend

CREATE friend={name: "A Friend"} RETURN friend;

add our friendship idempotently, so we can re-run the query without adding it several times, we return the relationship to check that it has not been created several times
```
START me=node:node_auto_index(name="Me"), friend=node:node_auto_index(name="A Friend") 
CREATE UNIQUE me-[r:FRIEND]->friend RETURN r;
```
rerun the query

update our friendship with a since property

START me=node:node_auto_index(name="Me"), friend=node:node_auto_index(name="A Friend")  
MATCH me-[r:FRIEND]->friend 
SET r.since='forever' 
RETURN r;

we pretend us being our friend and wanting to see which movies our friends have rated

START me=node:node_auto_index(name="A Friend")  
MATCH me-[:FRIEND]-friend-[r:RATED]->movie 
RETURN movie.title, avg(r.stars) as stars, collect(r.comment) as comments, count(*);

that's too little data, let's add some more friends and friendships

START me=node:node_auto_index(name="Me") 
FOREACH (i in range(1,10) : 
CREATE friend={name: "Friend "+i}, me-[:FRIEND]->friend);

Paths everywhere

same setup as before, with all the added friends and ratings
lets explore the relationships between the actors

All other movies that the matrix actors acted in ordered by occurrence

START m=node:node_auto_index(id="603")  
MATCH m<-[:ACTS_IN]-actor-[:ACTS_IN]->movie 
RETURN movie.title, count(*) order by count(*) desc;

obviously the Matrix trilogy, but also others, let's see which actors

START m=node:node_auto_index(id="603") 
MATCH m<-[:ACTS_IN]-actor-[:ACTS_IN]->movie 
RETURN movie.title, collect(actor.name), 
count(*) as count 
ORDER BY count desc;

what about co-acting, actors that acted together

START m=node:node_auto_index(id="603") 
MATCH m<-[:ACTS_IN]-actor-[:ACTS_IN]->movie
<-[:ACTS_IN]-colleague  
RETURN actor.name, collect(distinct colleague.name);

who of those other actors acted most often with anyone from the matrix cast

START m=node:node_auto_index(id="603") 
MATCH m<-[:ACTS_IN]-actor-[:ACTS_IN]->movie
<-[:ACTS_IN]-colleague 
RETURN colleague.name,count(*) 
ORDER BY count(*) desc LIMIT 10;

Paths everywhere

starting with paths, a path is a sequence of nodes and relationships from a start node to an end nod

we know that Trinity loves Neo, but how many paths exist between their actors; we limit the path length and the query as it exhaustively searches the graph otherwise

START neo=node:node_auto_index(name="Keanu Reeves"), 
trinity=node:node_auto_index(name="Carrie-Anne Moss") 
MATCH p = neo-[:ACTS_IN*0..5]-trinity  
RETURN p, length(p) 
LIMIT 10;

if that's a lot of data, we just want to look at the names and titles of the nods of this path

START neo=node:node_auto_index(name="Keanu Reeves"), 
trinity=node:node_auto_index(name="Carrie-Anne Moss") 
MATCH p = neo-[:ACTS_IN*0..5]-trinity  
RETURN extract(n in nodes(p) : 
coalesce(n.title?,n.name?)) as `names and titles`, 
length(p) 
ORDER BY length(p) LIMIT 10 ;

Alternative Setups
- Use the Neo4j Console for exploration, sharing and testing
- Deploy an instance of the graph to Heroku, upload the dataset and optionally add a read-only forwarder to expose the Web Interface
- Connect with the JDBC driver to a Neo4j Server for integration with existing tools

Cypher Tutorial

Learn Cypher - the Neo4j query language

Intro

First steps with Cypher

Explore a dataset

Updating the graph

Updating the graph

Paths everywhere

Paths everywhere

Alternative Setups

Try querying different graphs with Cypher online

Query with Cypher

Cypher Reference

Cypher Cheat Sheet (PDF)