












The general operators comprise:
DISTINCT
.
[]
Retrieve the unique eye colors from Person
nodes.
Query.
CREATE (a:Person { name: 'Anne', eyeColor: 'blue' }),(b:Person { name: 'Bill', eyeColor: 'brown' }),(c:Person { name: 'Carol', eyeColor: 'blue' })
WITH a, b, c
MATCH (p:Person)
RETURN DISTINCT p.eyeColor
Even though both 'Anne' and 'Carol' have blue eyes, 'blue' is only returned once.
p.eyeColor 

2 rows Nodes created: 3 Properties set: 6 Labels added: 3 


Try this query live. none CREATE (a:Person {name: 'Anne', eyeColor: 'blue'}), (b:Person {name: 'Bill', eyeColor: 'brown'}), (c:Person {name: 'Carol', eyeColor: 'blue'}) WITH a, b, c MATCH (p:Person) RETURN DISTINCT p.eyeColor
DISTINCT
is commonly used in conjunction with aggregating functions.
Query.
WITH { person: { name: 'Anne', age: 25 }} AS p
RETURN p.person.name
p.person.name 

1 row 

Try this query live. none WITH {person: {name: 'Anne', age: 25}} AS p RETURN p.person.name
Query.
CREATE (a:Restaurant { name: 'Hungry Jo', rating_hygiene: 10, rating_food: 7 }),(b:Restaurant { name: 'Buttercup Tea Rooms', rating_hygiene: 5, rating_food: 6 }),(c1:Category { name: 'hygiene' }),(c2:Category { name: 'food' })
WITH a, b, c1, c2
MATCH (restaurant:Restaurant),(category:Category)
WHERE restaurant["rating_" + category.name]> 6
RETURN DISTINCT restaurant.name
restaurant.name 

1 row Nodes created: 4 Properties set: 8 Labels added: 4 

Try this query live. none CREATE (a:Restaurant {name: 'Hungry Jo', rating_hygiene: 10, rating_food: 7}), (b:Restaurant {name: 'Buttercup Tea Rooms', rating_hygiene: 5, rating_food: 6}), (c1:Category {name: 'hygiene'}), (c2:Category {name: 'food'}) WITH a, b, c1, c2 MATCH (restaurant:Restaurant), (category:Category) WHERE restaurant["rating_" + category.name] > 6 RETURN DISTINCT restaurant.name
See Section 3.3.7.2, “Basic usage” for more details on dynamic property access.
The mathematical operators comprise:
+

*
/
%
^
Query.
WITH 2 AS number, 3 AS exponent
RETURN number ^ exponent AS result
result 

1 row 

Try this query live. none WITH 2 AS number, 3 AS exponent RETURN number ^ exponent AS result
Query.
WITH 3 AS a, 4 AS b
RETURN b  a AS result
result 

1 row 

Try this query live. none WITH 3 AS a, 4 AS b RETURN b  a AS result
The comparison operators comprise:
=
<>
<
>
<=
>=
IS NULL
IS NOT NULL
STARTS WITH
: perform casesensitive prefix searching on strings
ENDS WITH
: perform casesensitive suffix searching on strings
CONTAINS
: perform casesensitive inclusion searching in strings
Query.
WITH 4 AS one, 3 AS two
RETURN one > two AS result
result 

1 row 

Try this query live. none WITH 4 AS one, 3 AS two RETURN one > two AS result
See Section 3.2.5.9, “Equality and comparison of values” for more details on the behavior of comparison operators, and Section 3.3.7.8, “Using ranges” for more examples showing how these may be used.
Query.
WITH ['John', 'Mark', 'Jonathan', 'Bill'] AS somenames
UNWIND somenames AS names
WITH names AS candidate
WHERE candidate STARTS WITH 'Jo'
RETURN candidate
candidate 

2 rows 


Try this query live. none WITH ['John', 'Mark', 'Jonathan', 'Bill'] AS somenames UNWIND somenames AS names WITH names AS candidate WHERE candidate STARTS WITH 'Jo' RETURN candidate
Section 3.3.7.3, “String matching” contains more information regarding the stringspecific comparison operators as well as additional examples illustrating the usage thereof.
The boolean operators — also known as logical operators — comprise:
AND
OR
,
XOR
NOT
Here is the truth table for AND
, OR
, XOR
and NOT
.
a  b  a AND b

a OR b

a XOR b

NOT a
























































Query.
WITH [2, 4, 7, 9, 12] AS numberlist
UNWIND numberlist AS number
WITH number
WHERE number = 4 OR (number > 6 AND number < 10)
RETURN number
number 

3 rows 



Try this query live. none WITH [2, 4, 7, 9, 12] AS numberlist UNWIND numberlist AS number WITH number WHERE number = 4 OR (number > 6 AND number < 10) RETURN number
String operators comprise:
+
=~
Query.
WITH ['mouse', 'chair', 'door', 'house'] AS wordlist
UNWIND wordlist AS word
WITH word
WHERE word =~ '.*ous.*'
RETURN word
word 

2 rows 


Try this query live. none WITH ['mouse', 'chair', 'door', 'house'] AS wordlist UNWIND wordlist AS word WITH word WHERE word =~ '.*ous.*' RETURN word
Further information and examples regarding the use of regular expressions in filtering can be found in Section 3.3.7.4, “Regular expressions”. In addition, refer to the section called “Stringspecific comparison operators comprise:” for details on stringspecific comparison operators.
List operators comprise:
+
IN
[]
Query.
RETURN [1,2,3,4,5]+[6,7] AS myList
myList 

1 row 

Try this query live. none RETURN [1,2,3,4,5] + [6,7] AS myList
Query.
WITH [2, 3, 4, 5] AS numberlist
UNWIND numberlist AS number
WITH number
WHERE number IN [2, 3, 8]
RETURN number
number 

2 rows 


Try this query live. none WITH [2, 3, 4, 5] AS numberlist UNWIND numberlist AS number WITH number WHERE number IN [2, 3, 8] RETURN number
Query.
WITH ['Anne', 'John', 'Bill', 'Diane', 'Eve'] AS names
RETURN names[1..3] AS result
The square brackets will extract the elements from the start index 1
, and up to (but excluding) the end index 3
.
result 

1 row 

Try this query live. none WITH ['Anne', 'John', 'Bill', 'Diane', 'Eve'] AS names RETURN names[1..3] AS result
More details on lists can be found in Section 3.2.8.1, “Lists in general”.
Since version 2.0, the previously supported property operators 
Cypher supports comparing values (see Section 3.2.1, “Values”) by equality using the =
and <>
operators.
Values of the same type are only equal if they are the same identical value (e.g. 3 = 3
and "x" <> "xy"
).
Maps are only equal if they map exactly the same keys to equal values and lists are only equal if they contain the same sequence
of equal values (e.g. [3, 4] = [1+2, 8/2]
).
Values of different types are considered as equal according to the following rules:
null
with both the =
and the <>
operators always is null
.
This includes null = null
and null <> null
.
The only way to reliably test if a value v
is null
is by using the special v IS NULL
, or v IS NOT NULL
equality operators.
All other combinations of types of values cannot be compared with each other. Especially, nodes, relationships, and literal maps are incomparable with each other.
It is an error to compare values that cannot be compared.
The comparison operators <=
, <
(for ascending) and >=
, >
(for descending) are used to compare values for ordering.
The following points give some details on how the comparison is performed.
3 < 4
is true).
java.lang.Double.NaN
is regarded as being larger than all other numbers.
"x" < "xy"
).
false < true
.
null
(e.g. null < 3
is null
).
Comparisons can be chained arbitrarily, e.g., x < y <= z
is equivalent to x < y AND y <= z
.
Formally, if a, b, c, ..., y, z
are expressions and op1, op2, ..., opN
are comparison operators, then a op1 b op2 c ... y opN z
is equivalent to a op1 b and b op2 c and ... y opN z
.
Note that a op1 b op2 c
does not imply any kind of comparison between a
and c
, so that, e.g., x < y > z
is perfectly legal (although perhaps not elegant).
The example:
MATCH (n) WHERE 21 < n.age <= 30 RETURN n
is equivalent to
MATCH (n) WHERE 21 < n.age AND n.age <= 30 RETURN n
Thus it will match all nodes where the age is between 21 and 30.
This syntax extends to all equality and inequality comparisons, as well as extending to chains longer than three.
For example:
a < b = c <= d <> e
Is equivalent to:
a < b AND b = c AND c <= d AND d <> e
For other comparison operators, see Section 3.2.5.4, “Comparison operators”.