Predicate functions
Introduction
Predicates are boolean functions that return true
or false
for a given set of non-null
input.
They are most commonly used to filter out paths in the WHERE
part of a query.
Example graph
The following graph is used for the examples below:
To recreate it, run the following query against an empty Neo4j database:
CREATE
(keanu:Person {name:'Keanu Reeves', age:58, nationality:'Canadian'}),
(carrie:Person {name:'Carrie Anne Moss', age:55, nationality:'American'}),
(liam:Person {name:'Liam Neeson', age:70, nationality:'Northern Irish'}),
(guy:Person {name:'Guy Pearce', age:55, nationality:'Australian'}),
(kathryn:Person {name:'Kathryn Bigelow', age:71, nationality:'American'}),
(jessica:Person {name:'Jessica Chastain', age:45, address:''}),
(theMatrix:Movie {title:'The Matrix'}),
(keanu)-[:KNOWS {since: 1999}]->(carrie),
(keanu)-[:KNOWS {since: 2005}]->(liam),
(keanu)-[:KNOWS {since: 2010}]->(kathryn),
(kathryn)-[:KNOWS {since: 2012}]->(jessica),
(carrie)-[:KNOWS {since: 2008}]->(guy),
(liam)-[:KNOWS {since: 2009}]->(guy),
(keanu)-[:ACTED_IN]->(theMatrix),
(carrie)-[:ACTED_IN]->(theMatrix)
all()
Syntax |
|
||
Description |
Returns true if the predicate holds for all elements in the given |
||
Arguments |
Name |
Type |
Description |
|
|
A variable that can be used within the |
|
|
|
A predicate must hold for all elements in this list for the function to return |
|
|
|
A predicate that is tested against all items in the given list. |
|
Returns |
|
|
|
|
MATCH p = (a:Person {name: 'Keanu Reeves'})-[]-{2,}()
WHERE all(x IN nodes(p) WHERE x.age < 60)
RETURN [n IN nodes(p) | n.name] AS actorsList
All nodes in the returned paths have an age`property below `60
:
actorsList |
---|
|
Rows: 2 |
all()
on an empty LIST
WITH [] as emptyList
RETURN all(i in emptyList WHERE true) as allTrue, all(i in emptyList WHERE false) as allFalse
allTrue | allFalse |
---|---|
|
|
Rows: 1 |
allReduce()
Syntax |
|
||
Description |
Returns true if, during the stepwise evaluation of a value across the elements in a given |
||
Arguments |
Name |
Type |
Description |
|
|
A variable that holds the result of the |
|
|
|
The value of the |
|
|
|
A variable that holds the value of each element of |
|
|
|
The list that is being iterated over. |
|
|
|
An expression whose return value becomes the next value of the |
|
|
|
A predicate that is evaluated for each iteration.
It has access to the variable |
|
Returns |
|
|
|
If all evaluations of |
If any evaluations of |
|
|
The below query finds KNOWS
paths with a length of 3
where the accumulator
begins with first node’s age
and the accumulated age
values of all nodes in the path never exceeds 230
.
Paths that do not meet this requirement are excluded, such as the path with the sequence ["Keanu Reeves (58)", "Carrie Anne Moss (55)", "Guy Pearce (55)", "Liam Neeson (70)"]
which has an aggregated age
value of 238
.
MATCH (s) (()-[:KNOWS]-(n)){3}
WHERE allReduce(
acc = s.age,
node IN n | acc + node.age,
acc < 230
)
RETURN [i IN [s] + n | i.name || " (" + toString(i.age) || ")"] AS ageSequence,
reduce(acc = 0, node IN [s] + n | acc + node.age) AS aggregatedAges
ORDER BY aggregatedAges
ageSequence | aggregatedAges |
---|---|
|
|
|
|
Rows: 2 |
The next query uses allReduce()
to compare neighboring relationships.
It finds KNOWS
paths with a length of at least 3
where each relationship’s since
value is greater than the previous one and above 2000
.
MATCH path = ()-[r:KNOWS]-{3,}()
WHERE allReduce(
span = {},
rel IN r | { previous: span.current, current: rel.since },
(span.previous IS NULL OR span.previous < span.current) AND span.current > 2000
)
LET people = nodes(path)
RETURN [actor IN people | actor.name] AS connectedActors,
[rel IN r | rel.since] AS sinceYears
ORDER BY sinceYears
connectedActors | sinceYears |
---|---|
|
|
Rows: 1 |
any()
Syntax |
|
||
Description |
Returns true if the predicate holds for at least one element in the given |
||
Arguments |
Name |
Type |
Description |
|
|
A variable that can be used within the |
|
|
|
A predicate must hold for all elements in this list for the function to return |
|
|
|
A predicate that is tested against all items in the given list. |
|
Returns |
|
|
|
|
MATCH p = (n:Person {name: 'Keanu Reeves'})-[:KNOWS]-{3}()
WHERE any(rel IN relationships(p) WHERE rel.since < 2000)
RETURN [person IN nodes(p) | person.name] AS connectedActors,
[rel IN relationships(p) | rel.since] AS sinceYears
connectedActors | sinceYears |
---|---|
|
|
Rows: 1 |
any()
on an empty LIST
WITH [] as emptyList
RETURN any(i IN emptyList WHERE true) as anyTrue, any(i IN emptyList WHERE false) as anyFalse
anyTrue | anyFalse |
---|---|
|
|
Rows: 1 |
exists()
Syntax |
|
||
Description |
Returns true if a match for the pattern exists in the graph. |
||
Arguments |
Name |
Type |
Description |
|
|
A pattern to verify the existence of. |
|
Returns |
|
|
To check if a property is not |
MATCH (p:Person)
RETURN p.name AS name,
exists((p)-[:ACTED_IN]->()) AS has_acted_in_rel
This query returns the name
property of every Person
node, along with a boolean (true
or false
) indicating if those nodes have an ACTED_IN
relationship in the graph.
name | has_acted_in_rel |
---|---|
|
|
|
|
|
|
|
|
|
|
|
|
Rows: 6 |
For information about the |
isEmpty()
Syntax |
|
||
Description |
Checks whether a |
||
Arguments |
Name |
Type |
Description |
|
|
A value to be checked for emptiness. |
|
Returns |
|
MATCH (p:Person)
WHERE NOT isEmpty(p.nationality)
RETURN p.name, p.nationality
This query returns every Person
node in the graph with a set nationality
property value (i.e., all Person
nodes except for Jessica Chastain
):
p.name | p.nationality |
---|---|
|
|
|
|
|
|
|
|
|
|
Rows: 5 |
MATCH (n)
WHERE isEmpty(properties(n))
RETURN n
Because the example graph contains no empty nodes, nothing is returned:
(no changes, no records)
MATCH (p:Person)
WHERE isEmpty(p.address)
RETURN p.name AS name
The name
property of each node that has an empty STRING
address
property is returned:
name |
---|
|
Rows: 1 |
The function |
none()
Syntax |
|
||
Description |
Returns true if the predicate holds for no element in the given |
||
Arguments |
Name |
Type |
Description |
|
|
A variable that can be used within the |
|
|
|
A predicate must hold for all elements in this list for the function to return |
|
|
|
A predicate that is tested against all items in the given list. |
|
Returns |
|
|
|
|
MATCH p = (n:Person {name: 'Keanu Reeves'})-[]-{2}()
WHERE none(x IN nodes(p) WHERE x.age > 60)
RETURN [x IN nodes(p) | x.name] AS connectedActors
No nodes in the returned paths have an age
property with a greater value than 60
:
connectedActors |
---|
|
Rows: 1 |
none()
on an empty LIST
WITH [] as emptyList
RETURN none(i IN emptyList WHERE true) as noneTrue, none(i IN emptyList WHERE false) as noneFalse
noneTrue | noneFalse |
---|---|
|
|
Rows: 1 |
single()
Syntax |
|
||
Description |
Returns true if the predicate holds for exactly one of the elements in the given |
||
Arguments |
Name |
Type |
Description |
|
|
A variable that can be used within the |
|
|
|
A predicate must hold for all elements in this list for the function to return |
|
|
|
A predicate that is tested against all items in the given list. |
|
Returns |
|
|
|
|
MATCH p = (n:Person {name: 'Keanu Reeves'})-[:KNOWS]-+(b)
WHERE single(x IN [b] WHERE x.nationality = 'Northern Irish')
RETURN [person IN nodes(p) | person.name + " (" + person.nationality + ")"] AS northernIrishPaths
ORDER BY length(p)
northernIrishPaths |
---|
|
|
Rows: 2 |
single()
on an empty LIST
WITH [] as emptyList
RETURN single(i IN emptyList WHERE true) as singleTrue, single(i IN emptyList WHERE false) as singleFalse
singleTrue | singleFalse |
---|---|
|
|
Rows: 1 |