












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.
Result.
++
 p.eyeColor 
++
 "blue" 
 "brown" 
++
2 rows
Nodes created: 3
Properties set: 6
Labels added: 3
DISTINCT
is commonly used in conjunction with aggregating functions.
Query.
WITH { person: { name: 'Anne', age: 25 }} AS p
RETURN p.person.name
Result.
++
 p.person.name 
++
 "Anne" 
++
1 row
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
Result.
++
 restaurant.name 
++
 "Hungry Jo" 
++
1 row
Nodes created: 4
Properties set: 8
Labels added: 4
See Section 3.3.3.1, “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.
++
 result 
++
 8.0 
++
1 row
Query.
WITH 3 AS a, 4 AS b
RETURN b  a AS result
Result.
++
 result 
++
 7 
++
1 row
The comparison operators comprise:
=
<>
<
>
<=
>=
IS NULL
IS NOT NULL
Stringspecific comparison operators comprise:
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.
++
 result 
++
 true 
++
1 row
See Section 3.2.5.9, “Equality and comparison of values” for more details on the behavior of comparison operators, and Section 3.3.3.7, “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
Result.
++
 candidate 
++
 "John" 
 "Jonathan" 
++
2 rows
Section 3.3.3.2, “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
Result.
++
 number 
++
 4 
 7 
 9 
++
3 rows
String operators comprise:
+
=~
Query.
WITH ['mouse', 'chair', 'door', 'house'] AS wordlist
UNWIND wordlist AS word
WITH word
WHERE word =~ '.*ous.*'
RETURN word
Result.
++
 word 
++
 "mouse" 
 "house" 
++
2 rows
Further information and examples regarding the use of regular expressions in filtering can be found in Section 3.3.3.3, “Regular expressions”. In addition, refer to Section 3.2.5.4, “Comparison operators” for details on stringspecific comparison operators.
List operators comprise:
+
IN
[]
Query.
RETURN [1,2,3,4,5]+[6,7] AS myList
Result.
++
 myList 
++
 [1,2,3,4,5,6,7] 
++
1 row
Query.
WITH [2, 3, 4, 5] AS numberlist
UNWIND numberlist AS number
WITH number
WHERE number IN [2, 3, 8]
RETURN number
Result.
++
 number 
++
 2 
 3 
++
2 rows
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.
++
 result 
++
 ["John","Bill"] 
++
1 row
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”.