Neo4j Intro Training

Welcome

Find a seat. Say hi!
Grab a USB key, and plug it in.

Windows	Mac/Linux
Run the "Install-Neo4j.exe"	Start a terminal
When you see Neo4j desktop	When you see the command prompt,
Click the start button	Type "./bin/neo4j start"

Windows

Mac/Linux

Run the "Install-Neo4j.exe"

Start a terminal

When you see Neo4j desktop

When you see the command prompt,

Click the start button

Type "./bin/neo4j start"

Grab a coffee and get ready to begin!

Neo4j Tutorial

(you)-[:KNOW]->(Neo4j)

with Michael Hunger

info@neotechnology.com | @neo4j

Why did you come?

Answer five Questions

What is Neo4j?
Why would I use it?
How do I model data?
How do I enter data?
How do I query data?
and…
provide confidence start building
a graph enabled application

Schedule

  8.30am  -  Registration, installation and breakfast
  9.00am  -  Session 1: Graphs and Modeling
10.30am  -  Morning coffee break
10.45am  -  Session 2: Neo4j and Cypher
12.00pm  -  Lunch
  1.00pm  -  Session 3: Advanced queries using Cypher
  2.30pm  -  Afternoon coffee break
  2.45pm  -  Session 4: Next steps and Q&A
  4.00pm  -  End of training

(Introduction to Graphs)

But first an important message …

These are Charts …

Not Graphs

Leonhard Euler 1707-1783

Swiss Mathematician

7 Bridges of Königsberg

Königsberg (Prussia) - 1736

7 Bridges, one route?

7 Bridges of Königsberg - Approach

Identify parts → Landmasses & Bridges

7 Bridges of Königsberg - Model

It’s a graph → Nodes & Relationships

7 Bridges of Königsberg - Solution

Path finding → There was no route

So what about data?

Alice & Bob

Bob
Book
title
"Graph Databases"
Alice
Has Read
Friend Of
Has Read
Friend Of

Add Detail

Person
name
Bob
age
38
Book
title
"Graph Databases"
authors
"Ian Robinson, ..."
Person
name
Alice
age
34
Has Read
date
Jun-03
rating
4
Friend Of
Has Read
date
Dec-05
rating
5
Friend Of

Segue: Graphs in a Relational World

Tables

One table

Another one

A link table

JOINing them

This is the data

Explicit as a graph

Nodes

Relationships and …

Nodes, Relationships and Labels.

Modeling with graphs

Start with a whiteboard

1

2

3

4

5

Model incrementally

6

7

(Brief tour of Neo4j)

Neo4j Browser - finding help

Neo4j Browser - execute Cypher, visualize

Neo4j Browser - importing sample data

Neo4j Data browser - display more data

Coffee?

Intro to Cypher

Cypher is Neo4j’s graph query language

Declarative Pattern-Matching language
SQL-like syntax
Designed for graphs

It’s all about patterns

bg1

Triangle1

Triangle2

How?

Two nodes, one relationship

The graph

(a)-->(b)

Two nodes, one relationship

MATCH (a)--(b)
RETURN a, b

The pattern

The graph

ab1

ab2

ab3

Two nodes, one relationship

The graph

The code

(a)-->()

Two nodes, one relationship

MATCH (a)-->()
RETURN a.name

Two nodes, one relationship

MATCH (a)-->()
RETURN a.name

Two nodes, one relationship

The graph

The code

(a)-[r] - >()

Two nodes, one relationship

MATCH (a)-[r]->()
RETURN a.name, type(r)

Two nodes, one optional relationship

The graph

Optional stroke

OPTIONAL MATCH (a)-[r]->()
RETURN a.name, type(r)

Two nodes, one relationship

The graph

a
m
ACTED_IN

The code

(a)-[:ACTED_IN]→(m)

MATCH (a)-[:ACTED_IN]->(m)
RETURN a.name, m.title

Returning role properties

MATCH (a)-[r:ACTED_IN]->(m)
RETURN a.name, r.roles, m.title

Paths

The graph

The code

(a) - - >(b) - - >(c)

Paths

The graph

The code

(a) - - >(b)< - - (c)

Paths

The graph

a
m
d
ACTED_IN
DIRECTED

MATCH (a)-[:ACTED_IN]->(m)<-[:DIRECTED]-(d)
RETURN a.name, m.title, d.name

A Movies Query

The code

MATCH (a)-[:ACTED_IN]->(m)<-[:DIRECTED]-(d)
RETURN a.name, m.title, d.name;

The result

a.name	m.title	d.name
“Keanu Reeves”	“The Matrix”	“Andy Wachowski”
“Keanu Reeves”	“The Matrix Reloaded”	“Andy Wachowski”
“Noah Wyle”	“A Few Good Men”	“Rob Reiner”
“Tom Hanks”	“Cloud Atlas”	“Andy Wachowski”

a.name

m.title

d.name

“Keanu Reeves”

“The Matrix”

“Andy Wachowski”

“Keanu Reeves”

“The Matrix Reloaded”

“Andy Wachowski”

“Noah Wyle”

“A Few Good Men”

“Rob Reiner”

“Tom Hanks”

“Cloud Atlas”

“Andy Wachowski”

A Movies Query with alias

The code

MATCH (a)-[:ACTED_IN]->(m)<-[:DIRECTED]-(d)
RETURN a.name AS actor, m.title AS movie,
       d.name AS director;

The result

actor	movie	director
“Keanu Reeves”	“The Matrix”	“Andy Wachowski”
“Keanu Reeves”	“The Matrix Reloaded”	“Andy Wachowski”
“Noah Wyle”	“A Few Good Men”	“Rob Reiner”
“Tom Hanks”	“Cloud Atlas”	“Andy Wachowski”

actor

movie

director

“Keanu Reeves”

“The Matrix”

“Andy Wachowski”

“Keanu Reeves”

“The Matrix Reloaded”

“Andy Wachowski”

“Noah Wyle”

“A Few Good Men”

“Rob Reiner”

“Tom Hanks”

“Cloud Atlas”

“Andy Wachowski”

Paths

The graph

a
m
m
d
ACTED_IN
DIRECTED

The code

MATCH
  (a)-[:ACTED_IN]->(m), (m)<-[:DIRECTED]-(d)
RETURN a.name, m.title, d.name

Paths

a
m
m
d
ACTED_IN
DIRECTED

MATCH
  (a)-[:ACTED_IN]->(m), (d)-[:DIRECTED]->(m)
RETURN a.name, m.title, d.name

Paths

The graph

a
m
d
ACTED_IN
DIRECTED

The code

MATCH p=(a)-[:ACTED_IN]->(m)<-[:DIRECTED]-(d)
RETURN p

Paths

The graph

a
m
d
ACTED_IN
DIRECTED

MATCH p=(a)-[:ACTED_IN]->(m)<-[:DIRECTED]-(d)
RETURN nodes(p)

Paths

a
m
m
d
ACTED_IN
DIRECTED

MATCH
  p1=(a)-[:ACTED_IN]->(m), p2=(d)-[:DIRECTED]->(m)
RETURN p1, p2

Aggregation

MATCH (a)-[:ACTED_IN]->(m)<-[:DIRECTED]-(d)
RETURN a.name, m.title, d.name;

a.name	m.title	d.name
“Keanu Reeves”	“The Matrix”	“Andy Wachowski”
“Keanu Reeves”	“The Matrix Reloaded”	“Andy Wachowski”
“Noah Wyle”, “A Few Good Men”	“Rob Reiner”	“Tom Hanks”, “Cloud Atlas"

a.name

m.title

d.name

“Keanu Reeves”

“The Matrix”

“Andy Wachowski”

“Keanu Reeves”

“The Matrix Reloaded”

“Andy Wachowski”

“Noah Wyle”, “A Few Good Men”

“Rob Reiner”

“Tom Hanks”, “Cloud Atlas"

Aggregation functions

count(x) - add up the number of occurrences
min(x) - get the lowest value
max(x) - get the highest value
avg(x) - get the average of a numeric value
sum(x) - add up all values
collect(x) - collected all the occurrences into an array

Aggregation

MATCH (a)-[:ACTED_IN]->(m)<-[:DIRECTED]-(d)
RETURN a.name, d.name, count(*);

a.name	d.name	count(*)
“Aaron Sorkin"	“Rob Reiner”	2
“Keanu Reeves”	"Andy Wachowski”	3
“Hugo Weaving”	“Tom Tykwer”	1

a.name

d.name

count(*)

“Aaron Sorkin"

“Rob Reiner”

“Keanu Reeves”

"Andy Wachowski”

“Hugo Weaving”

“Tom Tykwer”

Aggregation

MATCH (a)-[:ACTED_IN]->(m)<-[:DIRECTED]-(d)
RETURN a.name, d.name, count(m);

a.name	d.name	count(m)
“Aaron Sorkin"	“Rob Reiner”	2
“Keanu Reeves”	"Andy Wachowski”	3
“Hugo Weaving”	“Tom Tykwer”	1

a.name

d.name

count(m)

“Aaron Sorkin"

“Rob Reiner”

“Keanu Reeves”

"Andy Wachowski”

“Hugo Weaving”

“Tom Tykwer”

As

MATCH (a)-[:ACTED_IN]->(m)<-[:DIRECTED]-(d)
RETURN
 a.name AS actor,
 d.name AS director,
 count(m) AS count;

actor	director	count
“Aaron Sorkin"	“Rob Reiner”	2
“Keanu Reeves”	"Andy Wachowski”	3
“Hugo Weaving”	“Tom Tykwer”	1

actor

director

count

“Aaron Sorkin"

“Rob Reiner”

“Keanu Reeves”

"Andy Wachowski”

“Hugo Weaving”

“Tom Tykwer”

Lab

Which directors acted also in their movie?

MATCH (a)-[:ACTED_IN]->(m)<-[:DIRECTED]-(a)
RETURN a.name, m.title;

Unique relationships in paths

MATCH (a)-[:ACTED_IN]->(m)<-[:ACTED_IN]-(a)
RETURN a.name, m.title

Sort and limit

MATCH (a)-[:ACTED_IN]->(m)<-[:DIRECTED]-(d)
RETURN a.name, d.name, count(*) AS count
ORDER BY count DESC
LIMIT 5

Aggregation

MATCH (a)-[:ACTED_IN]->(m)<-[:DIRECTED]-(d)
RETURN
  a.name,
  d.name,
  collect(m.title)

notitle

a
m
d
ACTED_IN
DIRECTED

Starting somewhere

Get all nodes

MATCH (n)
RETURN n

Find a specific node (within all-nodes)

MATCH (n)
WHERE has(n.name) AND n.name="Tom Hanks"
RETURN n

WHERE - filter the results
has(n.name) - the name property must exist
n.name = "Tom Hanks" - and have that value

The Graph

notitle

Find a specific node (with a label)

MATCH (tom:Person)
WHERE tom.name="Tom Hanks"
RETURN tom

:Person - Matches only nodes labeled as Person

The Graph

notitle

Start with a specific (labeled) node

MATCH (tom:Person)-[:ACTED_IN]->(movie:Movie)
WHERE tom.name="Tom Hanks"
RETURN movie.title

(Movies featuring Tom Hanks)

The Graph

notitle

Start with a specific labeled node

MATCH (tom:Person)-[:ACTED_IN]->(movie:Movie),
(director:Person)-[:DIRECTED]->(movie:Movie)
WHERE tom.name="Tom Hanks"
RETURN director.name

(Directors who worked with Tom Hanks)

The Graph

Tom Hanks

Movies

Directors

Start with a specific labeled node

MATCH (tom:Person)-[:ACTED_IN]->()<-[:DIRECTED]-(director)
WHERE tom.name="Tom Hanks"
RETURN DISTINCT director.name

(Directors who worked with Tom Hanks)

Create label-specific index

CREATE INDEX ON :Person(name)

CREATE INDEX ON :Movie(title)

Create two indexes.

nodes labeled as Person, indexed by name property
nodes labeled as Movie, indexed by title property

Labels on pattern "anchors"

MATCH (tom:Person)-[:ACTED_IN]->(movie),
(kevin:Person)-[:ACTED_IN]->(movie)
WHERE tom.name="Tom Hanks" AND
      kevin.name="Kevin Bacon"
RETURN DISTINCT movie.title

(Movies featuring both Tom Hanks and Kevin Bacon)

Conditions

MATCH (tom:Person)-[:ACTED_IN]->(movie:Movie)
WHERE tom.name="Tom Hanks"
AND movie.released < 1992
RETURN DISTINCT movie.title

(Movies in which Tom Hanks acted, that were released before 1992)

The Graph

Tom Hanks

Movies

Conditions on properties

MATCH (actor:Person)-[r:ACTED_IN]->(movie)
WHERE actor.name="Keanu Reeves"
AND "Neo" IN (r.roles)
RETURN DISTINCT movie.title

(Movies in which Keanu Reeves played Neo)

Conditions on properties

MATCH (actor:Person)-[r:ACTED_IN]->(movie)
WHERE actor.name="Keanu Reeves"
AND ANY( x IN r.roles WHERE x = "Neo")
RETURN DISTINCT movie.title

(Movies in which Keanu Reeves played Neo)

Conditions based on comparisons

MATCH (tom:Person)-[:ACTED_IN]->(movie),
(a:Person)-[:ACTED_IN]->(movie)
WHERE tom.name="Tom Hanks"
AND a.born < tom.born
RETURN DISTINCT a.name

(Actors who worked with Tom and are older than he was)

Conditions based on comparisons

MATCH (tom:Person)-[:ACTED_IN]->(movie),
(a:Person)-[:ACTED_IN]->(movie)
WHERE tom.name="Tom Hanks"
AND a.born < tom.born
RETURN DISTINCT a.name, (tom.born - a.born) AS diff

(Actors who worked with Tom and are older than he was)

Conditions based on patterns

MATCH (gene:Person)-[:ACTED_IN]->(movie),
(n)-[:ACTED_IN]->(movie)
WHERE gene.name="Gene Hackman"
RETURN DISTINCT n.name

(Actors who worked with Gene Hackman)

Conditions based on patterns

MATCH (gene:Person)-[:ACTED_IN]->(movie),
(n)-[:ACTED_IN]->(movie)
WHERE gene.name="Gene Hackman"
AND (n)-[:DIRECTED]->()
RETURN DISTINCT n.name

(Actors who worked with Gene and were directors of their own films)

Conditions based on patterns

MATCH (keanu:Person)-[:ACTED_IN]->(movie),
(n)-[:ACTED_IN]->(movie),
 (hugo:Person)
WHERE keanu.name="Keanu Reeves" AND
      hugo.name="Hugo Weaving"
AND NOT (hugo)-[:ACTED_IN]->(movie)
RETURN DISTINCT n.name

Wildcard matching on properties

MATCH (matrix:Movie)<-[r:ACTED_IN]-(a)
WHERE matrix.title="The Matrix"
AND a.name =~ ".*Emil.*"
RETURN a

(Actors who worked with Keanu, but not when he was also working with Hugo)

Lab

Who are the five busiest actors?

MATCH (a:Person)-[:ACTED_IN]->()
RETURN a.name, count(*) AS count
ORDER BY count DESC
LIMIT 5

Advanced lab

Recommend 3 actors that Keanu Reeves should work with (but hasn’t).

MATCH (keanu:Person)-[:ACTED_IN]->()<-[:ACTED_IN]-(c),
      (c)-[:ACTED_IN]->()<-[:ACTED_IN]-(coc)
WHERE keanu.name="Keanu Reeves"
AND NOT((keanu)-[:ACTED_IN]->()<-[:ACTED_IN]-(coc))
AND coc <> keanu
RETURN coc.name, count(coc)
ORDER BY count(coc) DESC
LIMIT 3

Coffee? Lunch?

Updating graphs with Cypher

Creating nodes

CREATE (p:Person {name:"Emil"})

MATCH (p:Person)
WHERE p.name="Emil"
RETURN p

Lab

Insert a Movie with the title of “Mystic River” an a “released” year of 1993

CREATE (m:Movie {title:"Mystic River", released:1993})

Adding properties

MATCH (movie:Movie)
WHERE movie.title="Mystic River"
//add the property
SET movie.tagline = "We bury our sins here, Dave. We wash them clean."
RETURN movie

Changing properties

MATCH (movie:Movie)
WHERE movie.title="Mystic River"
//set the property
SET movie.released = 2003
RETURN movie

Creating relationships

MATCH (movie:Movie),(kevin:Person)
WHERE movie.title="Mystic River" AND
      kevin.name="Kevin Bacon"
//create the relationship
CREATE UNIQUE (kevin)-[:ACTED_IN {roles:["Sean"]}]->(movie)

MATCH (kevin)-[:ACTED_IN]->(movie)
WHERE kevin.name="Kevin Bacon"
RETURN movie.title

Lab

Set Kevin Bacon’s roles in Mystic River from to “Sean Dev”

MATCH (kevin:Person)-[r:ACTED_IN]->(movie:Movie)
WHERE movie.title="Mystic River" AND
      kevin.name="Kevin Bacon"
SET r.roles = ["Sean Dev"]
RETURN r.roles

Lab

Change Kevin Bacon’s role in Mystic River  from “Sean Dev” to “Sean Devine”

MATCH (kevin:Person)-[r:ACTED_IN]->(movie:Movie)
WHERE movie.title="Mystic River" AND
      kevin.name="Kevin Bacon"
SET r.roles = ["Sean Devine"]
RETURN r.roles

Lab

Add Clint Eastwood as the director of Mystic River

MATCH (movie:Movie),(clint:Person)
WHERE movie.title="Mystic River" AND
      clint.name="Clint Eastwood"
CREATE UNIQUE (clint)-[:DIRECTED]->(movie)

Lab

List all the characters in the movie “The Matrix”

MATCH (matrix:Movie)<-[r:ACTED_IN]-()
WHERE matrix.title="The Matrix"
RETURN r.roles

Deleting nodes

MATCH (emil:Person)
WHERE emil.name="Emil Eifrem"
DELETE emil

(Wrong Error Message)

Deleting relationships

MATCH (emil:Person)-[r]-()
WHERE emil.name="Emil Eifrem"
DELETE r

Deleting nodes and relationships

MATCH (n)
OPTIONAL MATCH (n)-[r]->()
DELETE n, r

(delete all content in the database)

Lab

Add KNOWS relationships between all actors who were in the same movie

MATCH (a:Person)-[:ACTED_IN]->()<-[:ACTED_IN]-(b:Person)
//ATT!
CREATE UNIQUE (a)-[:KNOWS]->(b);

Match or Create is MERGE

MERGE (p:Person {name:"Clint Eastwood"})
RETURN p

Uses indexes, constraints and locks to guarantee unique lookup and creation

Match or Create is MERGE

MERGE (p:Person {name:"Clint Eastwood"})
ON CREATE SET p.created = timestamp()
ON MATCH SET p.accessed = coalesce(p.accessed,0)+1
RETURN p

ON CREATE x SET - executed on create
ON MATCH x SET - executed on match

Coffee?

More Cypher!

Matching multiple relationships

MATCH (a)-[:ACTED_IN|:DIRECTED]->()<-[:ACTED_IN|:DIRECTED]-(b)
CREATE UNIQUE (a)-[:KNOWS]->(b)

(Create KNOWS relationships between anyone, Actors or Directors, who worked together)

Variable length paths

The pattern

(a)-[*1..3]→(b)

Friends-of-Friends

MATCH (keanu:Person)-[:KNOWS*2]->(fof)
WHERE keanu.name="Keanu Reeves"
RETURN DISTINCT fof.name

Lab

Return Friends-of-Friends of Keanu Reeves who are not immediate friends

MATCH (keanu:Person)-[:KNOWS*2]-(fof)
WHERE keanu.name="Keanu Reeves"
AND NOT (keanu)-[:KNOWS]-(fof) AND NOT(keanu=fof)
RETURN DISTINCT fof.name

Bacon Number!

MATCH p=shortestPath(
  (charlize:Person)-[:KNOWS*]->(bacon:Person)
)
WHERE charlize.name="Charlize Theron" AND
      bacon.name="Kevin Bacon"
RETURN length(rels(p))

Lab

Return the names of the people joining Charlize to Kevin.

MATCH p=shortestPath((charlize:Person)-[:KNOWS*]->(bacon:Person))
WHERE charlize.name="Charlize Theron" AND
      bacon.name="Kevin Bacon"
RETURN [n in nodes(p) | n.name] AS names;