List functions
List functions return lists of different data entities.
Further details and examples of lists may be found in Lists and List operators.
Example graph
The following graph is used for the examples below:
To recreate the graph, run the following query in an empty Neo4j database:
CREATE
(alice:Person:Developer {name:'Alice', age: 38, eyes: 'brown'}),
(bob {name: 'Bob', age: 25, eyes: 'blue'}),
(charlie {name: 'Charlie', age: 53, eyes: 'green'}),
(daniel {name: 'Daniel', age: 54, eyes: 'brown'}),
(eskil {name: 'Eskil', age: 41, eyes: 'blue', array: ['one', 'two', 'three']}),
(alice)-[:KNOWS]->(bob),
(alice)-[:KNOWS]->(charlie),
(bob)-[:KNOWS]->(daniel),
(charlie)-[:KNOWS]->(daniel),
(bob)-[:MARRIED]->(eskil)
keys()
keys
returns a LIST<STRING>
containing the string representations for all the property names of a NODE
, RELATIONSHIP
, or MAP
.
Syntax:
keys(expression)
Returns:
|
Arguments:
Name | Description |
---|---|
|
An expression that returns a |
Considerations:
|
MATCH (a) WHERE a.name = 'Alice'
RETURN keys(a)
A LIST<STRING>
containing the names of all the properties on the node bound to a
is returned.
keys(a) |
---|
|
Rows: 1 |
labels()
labels
returns a LIST<STRING>
containing the string representations for all the labels of a NODE
.
Syntax:
labels(node)
Returns:
|
Arguments:
Name | Description |
---|---|
|
An expression that returns a single |
Considerations:
|
MATCH (a) WHERE a.name = 'Alice'
RETURN labels(a)
A LIST<STRING>
containing all the labels of the node bound to a
is returned.
labels(a) |
---|
|
Rows: 1 |
nodes()
nodes()
returns a LIST<NODE>
containing all the NODE
values in a PATH
.
Syntax:
nodes(path)
Returns:
|
Arguments:
Name | Description |
---|---|
|
An expression that returns a |
Considerations:
|
MATCH p = (a)-->(b)-->(c)
WHERE a.name = 'Alice' AND c.name = 'Eskil'
RETURN nodes(p)
A LIST<NODE>
containing all the nodes in the path p
is returned.
nodes(p) |
---|
|
Rows: 1 |
range()
range()
returns a LIST<INTEGER>
comprising all INTEGER
values within a range bounded by a start
value and an end
value, where the difference step
between any two consecutive values is constant; i.e. an arithmetic progression.
To create ranges with decreasing INTEGER
values, use a negative value step
.
The range is inclusive for non-empty ranges, and the arithmetic progression will therefore always contain start
and — depending on the values of start
, step
and end
— end
.
The only exception where the range does not contain start
are empty ranges.
An empty range will be returned if the value step
is negative and start - end
is positive, or vice versa, e.g. range(0, 5, -1)
.
Syntax:
range(start, end [, step])
Returns:
|
Arguments:
Name | Description |
---|---|
|
An expression that returns an |
|
An expression that returns an |
|
A numeric expression defining the difference between any two consecutive values, with a default of |
RETURN range(0, 10), range(2, 18, 3), range(0, 5, -1)
Three lists of numbers in the given ranges are returned.
range(0, 10) | range(2, 18, 3) | range(0, 5, -1) |
---|---|---|
|
|
|
Rows: 1 |
reduce()
reduce()
returns the value resulting from the application of an expression on each successive element in a list in conjunction with the result of the computation thus far.
This function will iterate through each element e
in the given list, run the expression on e
— taking into account the current partial result — and store the new partial result in the accumulator.
This function is analogous to the fold
or reduce
method in functional languages such as Lisp and Scala.
Syntax:
reduce(accumulator = initial, variable IN list | expression)
Returns:
The type of the value returned depends on the arguments provided, along with the semantics of |
Arguments:
Name | Description |
---|---|
|
A variable that will hold the result and the partial results as the list is iterated. |
|
An expression that runs once to give a starting value to the accumulator. |
|
An expression that returns a |
|
The closure will have a variable introduced in its context. We decide here which variable to use. |
|
This expression will run once per value in the list, and produce the result value. |
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 NODE
values in the PATH
are summed and returned as a single value.
reduction |
---|
|
Rows: 1 |
relationships()
relationships()
returns a LIST<RELATIONSHIP>
containing all the RELATIONSHIP
values in a PATH
..
Syntax:
relationships(path)
Returns:
|
Arguments:
Name | Description |
---|---|
|
An expression that returns a |
Considerations:
|
MATCH p = (a)-->(b)-->(c)
WHERE a.name = 'Alice' AND c.name = 'Eskil'
RETURN relationships(p)
A LIST<RELATIONSHIP>
containing all the RELATIONSHIP
values in the PATH
p
is returned.
relationships(p) |
---|
|
Rows: 1 |
reverse()
reverse()
returns a LIST<ANY>
in which the order of all elements in the given LIST<ANY>
have been reversed.
Syntax:
reverse(original)
Returns:
A |
Arguments:
Name | Description |
---|---|
|
An expression that returns a |
Considerations:
Any |
WITH [4923,'abc',521, null, 487] AS ids
RETURN reverse(ids)
reverse(ids) |
---|
|
Rows: 1 |
tail()
tail()
returns a LIST<ANY>
lresult
containing all the elements, excluding the first one, from a list list
.
Syntax:
tail(list)
Returns:
A |
Arguments:
Name | Description |
---|---|
|
An expression that returns a |
MATCH (a) WHERE a.name = 'Eskil'
RETURN a.array, tail(a.array)
The property named array
and a LIST<ANY>
comprising all but the first element of the array
property are returned.
a.array | tail(a.array) |
---|---|
|
|
Rows: 1 |
toBooleanList()
toBooleanList()
converts a LIST<ANY>
and returns a LIST<BOOLEAN>
.
If any values are not convertible to BOOLEAN
they will be null
in the LIST<BOOLEAN>
returned.
Syntax:
toBooleanList(list)
Returns:
A |
Arguments:
Name | Description |
---|---|
|
An expression that returns a |
Considerations:
Any |
Any |
If the |
If the |
The conversion for each value in |
RETURN toBooleanList(null) as noList,
toBooleanList([null, null]) as nullsInList,
toBooleanList(['a string', true, 'false', null, ['A','B']]) as mixedList
noList | nullsInList | mixedList |
---|---|---|
|
|
|
Rows: 1 |
toFloatList()
toFloatList()
converts a LIST<ANY>
of values and returns a LIST<FLOAT>
.
If any values are not convertible to FLOAT
they will be null
in the LIST<FLOAT>
returned.
Syntax:
toFloatList(list)
Returns:
A |
Arguments:
Name | Description |
---|---|
|
An expression that returns a |
Considerations:
Any |
Any |
If the |
If the |
The conversion for each value in |
RETURN toFloatList(null) as noList,
toFloatList([null, null]) as nullsInList,
toFloatList(['a string', 2.5, '3.14159', null, ['A','B']]) as mixedList
noList | nullsInList | mixedList |
---|---|---|
|
|
|
Rows: 1 |
toIntegerList()
toIntegerList()
converts a LIST<ANY>
of values and returns a LIST<INTEGER>
.
If any values are not convertible to INTEGER
they will be null
in the LIST<INTEGER>
returned.
Syntax:
toIntegerList(list)
Returns:
A |
Arguments:
Name | Description |
---|---|
|
An expression that returns a |
Considerations:
Any |
Any |
If the |
If the |
The conversion for each value in |
RETURN toIntegerList(null) as noList,
toIntegerList([null, null]) as nullsInList,
toIntegerList(['a string', 2, '5', null, ['A','B']]) as mixedList
noList | nullsInList | mixedList |
---|---|---|
|
|
|
Rows: 1 |
toStringList()
toStringList()
converts a LIST<ANY>
of values and returns a LIST<STRING>
.
If any values are not convertible to STRING
they will be null
in the LIST<STRING>
returned.
Syntax:
toStringList(list)
Returns:
A |
Arguments:
Name | Description |
---|---|
|
An expression that returns a |
Considerations:
Any |
Any |
If the |
If the |
The conversion for each value in |
RETURN toStringList(null) as noList,
toStringList([null, null]) as nullsInList,
toStringList(['already a string', 2, date({year:1955, month:11, day:5}), null, ['A','B']]) as mixedList
noList | nullsInList | mixedList |
---|---|---|
|
|
|
Rows: 1 |
Was this page helpful?