Prev |  | Next

## 13.3. Collection functions

Collection functions return collections of things — nodes in a path, and so on.

See also Section 8.4.5, “Collection operators”.

Figure 13.3. Graph

### 13.3.1. NODES

Returns all nodes in a path.

Syntax: `NODES( path )`

Arguments:

- path: A path.

Query.

    MATCH p=(a)-->(b)-->(c)
    WHERE a.name='Alice' AND c.name='Eskil'
    RETURN nodes(p)

All the nodes in the path `p` are returned by the example query.

Result

nodes(p)
1 row
`[Node[2]{name:"Alice",age:38,eyes:"brown"},Node[3]{name:"Bob",age:25,eyes:"blue"},Node[1]{name:"Eskil",age:41,eyes:"blue",array:["one","two","three"]}]`

### 13.3.2. RELATIONSHIPS

Returns all relationships in a path.

Syntax: `RELATIONSHIPS( path )`

Arguments:

- path: A path.

Query.

    MATCH p=(a)-->(b)-->(c)
    WHERE a.name='Alice' AND c.name='Eskil'
    RETURN relationships(p)

All the relationships in the path `p` are returned.

Result

relationships(p)
1 row
`[:KNOWS[0]{},:MARRIED[4]{}]`

### 13.3.3. LABELS

Returns a collection of string representations for the labels attached to a node.

Syntax: `LABELS( node )`

Arguments:

- node: Any expression that returns a single node

Query.

    MATCH (a)
    WHERE a.name='Alice'
    RETURN labels(a)

The labels of `n` is returned by the query.

Result

labels(a)
1 row
`["foo","bar"]`

### 13.3.4. EXTRACT

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:

- collection: An expression that returns a collection
- identifier: The closure will have an identifier introduced in it’s context. Here you decide which identifier to use.
- expression: This expression will run once per value in the collection, and produces the result collection.

Query.

    MATCH p=(a)-->(b)-->(c)
    WHERE a.name='Alice' AND b.name='Bob' AND c.name='Daniel'
    RETURN extract(n IN nodes(p)| n.age) AS extracted

The age property of all nodes in the path are returned.

Result

extracted
1 row
`[38,25,54]`

### 13.3.5. FILTER

`FILTER` returns all the elements in a collection that comply to a predicate.

Syntax: `FILTER(identifier in collection WHERE predicate)`

Arguments:

- collection: An expression that returns a collection
- identifier: This is the identifier that can be used from the predicate.
- predicate: A predicate that is tested against all items in the collection.

Query.

    MATCH (a)
    WHERE a.name='Eskil'
    RETURN a.array, filter(x IN a.array WHERE length(x)= 3)

This returns the property named `array` and a list of values in it, which have the length `3`.

Result

a.array | filter(x in a.array WHERE length(x) = 3)
--- | ---
1 row
`["one","two","three"]` | `["one","two"]`

### 13.3.6. TAIL

`TAIL` returns all but the first element in a collection.

Syntax: `TAIL( expression )`

Arguments:

- expression: This expression should return a collection of some kind.

Query.

    MATCH (a)
    WHERE a.name='Eskil'
    RETURN a.array, tail(a.array)

This returns the property named `array` and all elements of that property except the first one.

Result

a.array | tail(a.array)
--- | ---
1 row
`["one","two","three"]` | `["two","three"]`

### 13.3.7. RANGE

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:

- start: A numerical expression.
- end: A numerical expression.
- step: A numerical expression.

Query.

    RETURN range(0,10), range(2,18,3)

Two lists of numbers are returned.

Result

range(0,10) | range(2,18,3)
--- | ---
1 row
`[0,1,2,3,4,5,6,7,8,9,10]` | `[2,5,8,11,14,17]`

### 13.3.8. REDUCE

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:

- accumulator: An identifier that will hold the result and the partial results as the collection is iterated
- initial: An expression that runs once to give a starting value to the accumulator
- collection: An expression that returns a collection
- identifier: The closure will have an identifier introduced in it’s context. Here you decide which identifier to use.
- expression: This expression will run once per value in the collection, and produces the result value.

Query.

    MATCH p=(a)-->(b)-->(c)
    WHERE a.name='Alice' AND b.name='Bob' AND c.name='Daniel'
    RETURN reduce(totalAge = 0, n IN nodes(p)| totalAge + n.age) AS reduction

The age property of all nodes in the path are summed and returned as a single value.

Result

reduction
1 row
`117`

Copyright © 2014 Neo Technology

Prev | Up | Next
| Home |