Cheatsheet.md

openCypher Syntax Cheatsheet

The below are some common examples of openCypher Syntax based upon the air-routes dataset provided by Kelvin Lawrence.

Table of Contents

• Read Queries
  • Pattern Matching
    • Find Nodes with Label
    • Find Nodes by Label and Property
    • Find pattern
    • Find path pattern
    • Find optional pattern
    • Find if something exists
  • Looping
    • Fixed number of loops
    • Range of hops
    • Range of hops (minimum boundary only)
    • Range of hops (maximum boundary only)
  • Returning Values
    • Return everything
    • Return property
    • Return property with alias
    • Return distinct values
    • Order results ascending
    • Order results descending
    • Return count of results
    • Limit results
    • Paginate results
    • Join distinct set from two queries
    • Join combined set from two queries
• Write Queries
  • Creating Data
    • Create a node
    • Create a node with label and no properties
    • Create a node with label and properties
    • Create relationship
    • Create relationship with properties
    • Create a path
    • Create from a list
  • Updating Data
    • Set a property
    • Remove a property
    • Merge a node
  • Deleting Data
    • Delete a node
    • Delete a node and relationships
    • Delete relationships
• Operators
• Functions

Read Queries

Pattern Matching

Pattern matching is the most basic actions one can do in openCypher and is the basis for all read queries.

Find Nodes with Label

MATCH (a:airport) RETURN a

Find Nodes by Label and Property

MATCH (a:airport {code: 'SEA'}) RETURN a

MATCH (a:airport) WHERE a.code='SEA' RETURN a

Find pattern

MATCH (a:airport {code: 'SEA'})-[:route]->(d) RETURN d

MATCH (a:airport {code: 'SEA'})<-[:route]-(d) RETURN d

Find path pattern

MATCH p=(a:airport {code: 'SEA'})-[:route]->(d) RETURN p

Find optional pattern

OPTIONAL MATCH (a:airport {code: 'SEA'})-[:route]->(d) RETURN d

Find if something exists

MATCH (a:airport {code: 'SEA'})-[:route]->(d) RETURN d

Looping

Looping through connections is a common pattern in property graphs and can be accomplished using either fixed or variable length paths.

Fixed number of loops

MATCH (a:airport {code: 'SEA'}*2)-[:route]->(d) RETURN d

Range of hops

MATCH (a:airport {code: 'SEA'})-[:route*1..3]->(d) RETURN d

Range of hops (minimum boundary only)

MATCH (a:airport {code: 'SEA'})-[:route*1..]->(d) RETURN d

Range of hops (maximum boundary only)

MATCH (a:airport {code: 'SEA'})-[:route*..3]->(d) RETURN d

Returning Values

Each read query must specify how to return values from the query.

Return everything

MATCH (a) RETURN *

Return property

MATCH (a:airport) RETURN a.city

Return property with alias

MATCH (a:airport) RETURN a.city AS dest

Return distinct values

MATCH (a:airport) RETURN DISTINCT a.region

Order results ascending

MATCH (a:airport) RETURN a ORDER BY a.elev

Order results descending

MATCH (a:airport) RETURN a ORDER BY a.elev DESC

Return count of results

MATCH (a:airport) RETURN count(a)

Limit results

MATCH (a:airport) RETURN a LIMIT 5

Paginate results

MATCH (a:airport) RETURN a SKIP 5 LIMIT 5

Join distinct set from two queries

MATCH (a:airport {code:'SEA'}) 
RETURN a.city
UNION 
MATCH (a:airport {code:'ANC'}) 
RETURN a.elev

Join combined set from two queries

MATCH (a:airport {code:'SEA'})-->(d) 
RETURN d.city
UNION ALL
MATCH (a:airport {code:'ANC'})-->(d) 
RETURN d.city

Write Queries

Creating Data

Create a node

CREATE (a)

Create a node with label and no properties

CREATE (a:airport)

Create a node with label and properties

CREATE (a:airport {code: 'FOO'})

Create relationship

MATCH (a:airport {code:'SEA'}), (b:airport {code:'ANC'})
CREATE (a)-[r:route]->(b)
RETURN r

Create relationship with properties

MATCH (a:airport {code:'SEA'}), (b:airport {code:'ANC'})
CREATE (a)-[r:route {dist: 1000}]->(b)
RETURN r

Create a path

CREATE p = (a:airport {code:'Foo'})-[:route]->(a:airport {code:'Bar'})
RETURN p

Create from a list

UNWIND [{code: 'foo'}, {code: 'bar'}] AS properties
CREATE (a:airport) SET a = properties

Updating Data

Set a property

MATCH (a:airport {code: 'SEA'})
SET a.foo='bar'

Remove a property

MATCH (a:airport {code: 'SEA'})
SET a.foo=null

MATCH (a:airport {code: 'SEA'})
REMOVE a.foo

Merge a node

MERGE (a:airport {code: 'SEA'})
  ON CREATE SET n.created = timestamp()
  ON MATCH SET
    n.counter = coalesce(n.counter, 0) + 1,
    n.accessTime = timestamp()

Deleting Data

Delete a node

DELETE (a:airport {code: 'SEA'})

Delete a node and relationships

MATCH (a:airport {code: 'SEA'})
DETACH DELETE a

Delete relationships

MATCH (a:airport {code:'SEA'})-[r]->(d) 
DELETE r

Operators

Type	Operators
General	DISTINCT, x.y (property access)
Math	+, -, *, /, %, ^
Comparison	=, >, <, <>, <=, >=, IS NULL, IS NOT NULL
Boolean	AND, OR, NOT, XOR
String	STARTS WITH, ENDS WITH, CONTAINS, +
LIST	+, IN, []

Functions

Type	Functions
Predicate	exists()
Scalar	coalesce(), endNode(), head(), id(0, last(), length(), properties(), size(), startNode(), timestamp(), toBoolean(), toFloat(), toInteger(), type()
Aggregating	avg(), collect(), count(), max(), min(), percentileCont(), percentileDisc(), stDev(), stDevP(), sum()
List	keys(), labels(), nodes(), range(), relationships(), reverse(), tail()
Math - numeric	abs(), ceil(), floor(), rand(), round(), sign()
Math - logarithmic	e(), exp(), log(), log10(), sqrt()
Math - trigonometric	acos(), asin(), atan(), atan2(), cos(), cot(), degree(), pi(), radians(), sin(), tan()
String	left(), lTrim(), replace(), reverse(), right(), rTrim(), split(), substring(), toLower(), toString(), toUpper(), trim()