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 |
|
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.
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.
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
.
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.
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.
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.
Copyright © 2013 Neo Technology