Collection functions return collections of things — nodes in a path, and so on.
See also Section 11.1.5, “Collection operators”.
Returns all nodes in a path.
Syntax: NODES( path )
Arguments:
Query.
START a=node(3), c=node(2) MATCH p=a-->b-->c RETURN NODES(p)
All the nodes in the path p
are returned by the example query.
Result
NODES(p) |
---|
1 row |
|
Try this query live. (1) {"age":54,"eyes":"brown","name":"D"} (2) {"age":41,"array":["one","two","three"],"eyes":"blue","name":"E"} (3) {"age":38,"eyes":"brown","name":"A"} (4) {"age":25,"eyes":"blue","name":"B"} (5) {"age":53,"eyes":"green","name":"C"} (3)-[:KNOWS]->(4) {} (3)-[:KNOWS]->(5) {} (4)-[:KNOWS]->(1) {} (4)-[:MARRIED]->(2) {} (5)-[:KNOWS]->(1) {} start a=node(3), c=node(2) match p=a-->b-->c return NODES(p)
Returns all relationships in a path.
Syntax: RELATIONSHIPS( path )
Arguments:
Query.
START a=node(3), c=node(2) MATCH p=a-->b-->c RETURN RELATIONSHIPS(p)
All the relationships in the path p
are returned.
Try this query live. (1) {"age":54,"eyes":"brown","name":"D"} (2) {"age":41,"array":["one","two","three"],"eyes":"blue","name":"E"} (3) {"age":38,"eyes":"brown","name":"A"} (4) {"age":25,"eyes":"blue","name":"B"} (5) {"age":53,"eyes":"green","name":"C"} (3)-[:KNOWS]->(4) {} (3)-[:KNOWS]->(5) {} (4)-[:KNOWS]->(1) {} (4)-[:MARRIED]->(2) {} (5)-[:KNOWS]->(1) {} start a=node(3), c=node(2) match p=a-->b-->c return RELATIONSHIPS(p)
To return a single property, or the value of a function from a collection of nodes or relationships,
you can use EXTRACT
. It will go through a collection, run an expression on every element, and return the results
in an collection with these values. It works like the map
method in functional languages such as Lisp and Scala.
Syntax: EXTRACT( identifier in collection : expression )
Arguments:
Query.
START a=node(3), b=node(4), c=node(1) MATCH p=a-->b-->c RETURN extract(n in nodes(p) : n.age)
The age property of all nodes in the path are returned.
Try this query live. (1) {"age":54,"eyes":"brown","name":"D"} (2) {"age":41,"array":["one","two","three"],"eyes":"blue","name":"E"} (3) {"age":38,"eyes":"brown","name":"A"} (4) {"age":25,"eyes":"blue","name":"B"} (5) {"age":53,"eyes":"green","name":"C"} (3)-[:KNOWS]->(4) {} (3)-[:KNOWS]->(5) {} (4)-[:KNOWS]->(1) {} (4)-[:MARRIED]->(2) {} (5)-[:KNOWS]->(1) {} start a=node(3), b=node(4), c=node(1) match p=a-->b-->c return extract(n in nodes(p) : n.age)
FILTER
returns all the elements in a collection that comply to a predicate.
Syntax: FILTER(identifier in collection : predicate)
Arguments:
Query.
START a=node(2) RETURN a.array, filter(x in a.array : length(x) = 3)
This returns the property named array
and a list of values in it, which have the length 3
.
Try this query live. (1) {"age":54,"eyes":"brown","name":"D"} (2) {"age":41,"array":["one","two","three"],"eyes":"blue","name":"E"} (3) {"age":38,"eyes":"brown","name":"A"} (4) {"age":25,"eyes":"blue","name":"B"} (5) {"age":53,"eyes":"green","name":"C"} (3)-[:KNOWS]->(4) {} (3)-[:KNOWS]->(5) {} (4)-[:KNOWS]->(1) {} (4)-[:MARRIED]->(2) {} (5)-[:KNOWS]->(1) {} start a=node(2) return a.array, filter(x in a.array : length(x) = 3)
TAIL
returns all but the first element in a collection.
Syntax: TAIL( expression )
Arguments:
Query.
START a=node(2) RETURN a.array, tail(a.array)
This returns the property named array
and all elements of that property except the first one.
Try this query live. (1) {"age":54,"eyes":"brown","name":"D"} (2) {"age":41,"array":["one","two","three"],"eyes":"blue","name":"E"} (3) {"age":38,"eyes":"brown","name":"A"} (4) {"age":25,"eyes":"blue","name":"B"} (5) {"age":53,"eyes":"green","name":"C"} (3)-[:KNOWS]->(4) {} (3)-[:KNOWS]->(5) {} (4)-[:KNOWS]->(1) {} (4)-[:MARRIED]->(2) {} (5)-[:KNOWS]->(1) {} start a=node(2) return a.array, tail(a.array)
Returns numerical values in a range with a non-zero step value step. Range is inclusive in both ends.
Syntax: RANGE( start, end [, step] )
Arguments:
Query.
START n=node(1) RETURN range(0,10), range(2,18,3)
Two lists of numbers are returned.
Try this query live. (1) {"age":54,"eyes":"brown","name":"D"} (2) {"age":41,"array":["one","two","three"],"eyes":"blue","name":"E"} (3) {"age":38,"eyes":"brown","name":"A"} (4) {"age":25,"eyes":"blue","name":"B"} (5) {"age":53,"eyes":"green","name":"C"} (3)-[:KNOWS]->(4) {} (3)-[:KNOWS]->(5) {} (4)-[:KNOWS]->(1) {} (4)-[:MARRIED]->(2) {} (5)-[:KNOWS]->(1) {} start n=node(1) return range(0,10), range(2,18,3)
To run an expression against individual elements of a collection, and store the result of the expression in
an accumulator, you can use REDUCE
. It will go through a collection, run an expression on every element, storing the partial result
in the accumulator. It works like the fold
or reduce
method in functional languages such as Lisp and Scala.
Syntax: REDUCE( accumulator = initial, identifier in collection : expression )
Arguments:
Query.
START a=node(3), b=node(4), c=node(1) MATCH p=a-->b-->c RETURN reduce(totalAge = 0, n in nodes(p) : totalAge + n.age)
The age property of all nodes in the path are summed and returned as a single value.
Try this query live. (1) {"age":54,"eyes":"brown","name":"D"} (2) {"age":41,"array":["one","two","three"],"eyes":"blue","name":"E"} (3) {"age":38,"eyes":"brown","name":"A"} (4) {"age":25,"eyes":"blue","name":"B"} (5) {"age":53,"eyes":"green","name":"C"} (3)-[:KNOWS]->(4) {} (3)-[:KNOWS]->(5) {} (4)-[:KNOWS]->(1) {} (4)-[:MARRIED]->(2) {} (5)-[:KNOWS]->(1) {} start a=node(3), b=node(4), c=node(1) match p=a-->b-->c return reduce(totalAge = 0, n in nodes(p) : totalAge + n.age)
Copyright © 2013 Neo Technology