














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] AS ps
UNWIND ps AS p
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] AS ps UNWIND ps AS p 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 behavior of the 
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.7.10, “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.
Temporal operators comprise:
+

*
/
The following table shows — for each combination of operation and operand type — the type of the value returned from the application of each temporal operator:
Operator  Lefthand operand  Righthand operand  Type of result 

Temporal instant 
Duration 
The type of the temporal instant 

Duration 
Temporal instant 
The type of the temporal instant 

Temporal instant 
Duration 
The type of the temporal instant 

Duration 
Duration 
Duration 

Duration 
Duration 
Duration 

Duration 
Duration 

Duration 
Duration 

Duration 
Duration 
Query.
WITH localdatetime({ year:1984, month:10, day:11, hour:12, minute:31, second:14 }) AS aDateTime, duration({ years: 12, nanoseconds: 2 }) AS aDuration
RETURN aDateTime + aDuration, aDateTime  aDuration
aDateTime + aDuration  aDateTime  aDuration 

1 row 



Try this query live. none WITH localdatetime({year:1984, month:10, day:11, hour:12, minute:31, second:14}) AS aDateTime, duration({years: 12, nanoseconds: 2}) AS aDuration RETURN aDateTime + aDuration, aDateTime  aDuration
Components of a Duration that do not apply to the temporal instant are ignored. For example, when adding a Duration to a Date, the hours, minutes, seconds and nanoseconds of the Duration are ignored (Time behaves in an analogous manner):
Query.
WITH date({ year:1984, month:10, day:11 }) AS aDate, duration({ years: 12, nanoseconds: 2 }) AS aDuration
RETURN aDate + aDuration, aDate  aDuration
aDate + aDuration  aDate  aDuration 

1 row 



Try this query live. none WITH date({year:1984, month:10, day:11}) AS aDate, duration({years: 12, nanoseconds: 2}) AS aDuration RETURN aDate + aDuration, aDate  aDuration
Adding two durations to a temporal instant is not an associative operation. This is because nonexisting dates are truncated to the nearest existing date:
Query.
RETURN (date("20110131")+ duration("P1M"))+ duration("P12M") AS date1, date("20110131")+(duration("P1M")+ duration("P12M")) AS date2
date1  date2 

1 row 



Try this query live. none RETURN (date("20110131") + duration("P1M")) + duration("P12M") AS date1, date("20110131") + (duration("P1M") + duration("P12M")) AS date2
Query.
WITH duration({ years: 12, months: 5, days: 14, hours: 16, minutes: 12, seconds: 70, nanoseconds: 1 }) AS duration1, duration({ months:1, days: 14, hours: 16, minutes: 12, seconds: 70 }) AS duration2
RETURN duration1, duration2, duration1 + duration2, duration1  duration2
duration1  duration2  duration1 + duration2  duration1  duration2 

1 row 





Try this query live. none WITH duration({years: 12, months: 5, days: 14, hours: 16, minutes: 12, seconds: 70, nanoseconds: 1}) as duration1, duration({months:1, days: 14, hours: 16, minutes: 12, seconds: 70}) AS duration2 RETURN duration1, duration2, duration1 + duration2, duration1  duration2
These operations are interpreted simply as componentwise operations with overflow to smaller units based on an average length of units in the case of division (and multiplication with fractions).
Query.
WITH duration({ days: 14, minutes: 12, seconds: 70, nanoseconds: 1 }) AS aDuration
RETURN aDuration, aDuration * 2, aDuration / 3
aDuration  aDuration * 2  aDuration / 3 

1 row 




Try this query live. none WITH duration({days: 14, minutes: 12, seconds: 70, nanoseconds: 1}) AS aDuration RETURN aDuration, aDuration * 2, aDuration / 3
List operators comprise:
l_{1}
and l_{2}
: [l_{1}] + [l_{2}]
e
exists in a list l
: e IN [l]
[]
The behavior of the 
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
The general rule is that the IN
operator will evaluate to true
if the list given as the righthand operand contains an element which has the same type and contents (or value) as the lefthand operand.
Lists are only comparable to other lists, and elements of a list l
are compared pairwise in ascending order from the first element in l
to the last element in l
.
The following query checks whether or not the list [2, 1]
is an element of the list [1, [2, 1], 3]
:
Query.
RETURN [2, 1] IN [1,[2, 1], 3] AS inList
The query evaluates to true
as the righthand list contains, as an element, the list [1, 2]
which is of the same type (a list) and contains the same contents (the numbers 2
and 1
in the given order) as the lefthand operand.
If the lefthand operator had been [1, 2]
instead of [2, 1]
, the query would have returned false
.
inList 

1 row 

Try this query live. none RETURN [2, 1] IN [1, [2, 1], 3] AS inList
At first glance, the contents of the lefthand operand and the righthand operand appear to be the same in the following query:
Query.
RETURN [1, 2] IN [1, 2] AS inList
However, IN
evaluates to false
as the righthand operand does not contain an element that is of the same type — i.e. a list — as the lefthandoperand.
inList 

1 row 

Try this query live. none RETURN [1, 2] IN [1, 2] AS inList
The following query can be used to ascertain whether or not a list l_{lhs}
— obtained from, say, the labels() function — contains at least one element that is also present in another list l_{rhs}
:
MATCH (n)
WHERE size([l IN labels(n) WHERE l IN ['Person', 'Employee']  1]) > 0
RETURN count(n)
As long as labels(n)
returns either Person
or Employee
(or both), the query will return a value greater than zero.
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.11.1, “Lists in general”.
Since version 2.0, the previously supported property operators 
Cypher supports comparing values (see Section 3.2.1, “Values and types”) 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
.
Comparison of spatial values:
null
.
a
and b
within the same CRS, a
is considered to be greater than b
if a.x > b.x
and a.y > b.y
(and a.z > b.z
for 3D points).
a
is considered less than b
if a.x < b.x
and a.y < b.y
(and a.z < b.z
for 3D points).
null
.
Ordering of spatial values:
ORDER BY
requires all values to be orderable.
x
first, then y
and finally z
.
Comparison of temporal values:
null
.
If the type, point in time, offset, and time zone name are all equal, then the values are equal, and any difference in order
is impossible to observe.
Ordering of temporal values:
ORDER BY
requires all values to be orderable.
Since no complete comparison order can be defined for Duration values, we define an order for ORDER BY
specifically for Duration:
365.2425
days long (PT8765H49M12S
), all months were 30.436875
(1/12
year) days long (PT730H29M06S
), and all days were 24
hours long ^{[1]}.
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.7.4, “Comparison operators”.
^{[1] }The 365.2425
days per year comes from the frequency of leap years. A leap year occurs on a year with an ordinal number divisible by 4
, that is not divisible by 100
, unless it divisible by 400
. This means that over 400
years there are ((365 * 4 + 1) * 25  1) * 4 + 1 = 146097
days, which means an average of 365.2425
days per year.