Overview

A quantified path pattern constructs a path of variable length, where either the entire path or a segment of it is repeated a specified number of times. A quantified path pattern can be formed by applying a quantifier to either an edge pattern or a parenthesized path pattern.

<quantified path pattern> ::= <quantified edges> | <quantified paths>
  
<quantified edges> ::= <edge pattern> <quantifier>

<quantified paths> ::= <parenthesized path pattern> <quantifier>

In implementation, a quantified path pattern must be concatenated with other path factors, explicitly or implicitly, using a node pattern. Refer to the examples for further clarification.

Quantifiers

A quantifier is written as postfix on either an edge pattern or a parenthesized path pattern.

When the repetition of 0 is indicated, a path (or subpath) with zero edges that only contains the initial node will be included in the matchings.

Syntactic restrictions are in place to prevent infinite looping, which could occur when an unbounded quantifier is used to match a graph that contains cycles.

Quantified Edges

Quantified edges are built by an edge pattern followed by a quantifier that specifies how many times the edge repeats. Note that the quantifier can be applied to both full and abbreviated edge patterns.

This path pattern expression is equivalent to:

The repeated edges are implicitly connected by empty node patterns.

Example Graph

The following examples run against this graph:

To create this graph, run the following query against an empty graph:

INSERT (purplechalk:User {_id: "U01", name: "purplechalk"}),
       (mochaeach:User {_id: "U02", name: "mochaeach"}),
       (rowlock:User {_id: "U03", name: "rowlock"}),
       (quasar92:User {_id: "U04", name: "Quasar92"}),
       (velvet:User {_id: "U05", name: "Velvet"}),
       (brainy:User {_id: "U06", name: "Brainy"}),
       (quickfox:User {_id: "U07", name: "Quickfox"}),
       (inception:Movie {_id: "M01", name: "Inception"}),
       (purplechalk)-[:Follows]->(mochaeach),
       (mochaeach)-[:Follows]->(rowlock),
       (rowlock)-[:Follows]->(quasar92),
       (quasar92)-[:Follows]->(velvet),
       (brainy)-[:Follows]->(mochaeach),
       (mochaeach)-[:Likes]->(inception),
       (quickfox)-[:Likes]->(inception)

Fixed Lowerbound and Upperbound

Gets users who Brainy can reach by 1 to 3 outgoing edges labeled Follows:

MATCH (:User {name: 'Brainy'})-[:Follows]->{1,3}(u:User)
RETURN collect_list(u.name) AS names

Result:

Fixed Length

Gets users who Brainy can reach by exactly 2 outgoing edges labeled Follows:

MATCH (:User {name: 'Brainy'})-[:Follows]->{2}(u:User)
RETURN collect_list(u.name)  AS names

Result:

Fixed Lowerbound

Gets users who Brainy can reach by 2 or more edges labeled Follows:

MATCH (:User {name: 'Brainy'})-[:Follows]-{2,}(u:User)
RETURN collect_list(u.name) AS names

Result:

Gets users who Brainy can reach by 0 or more outgoing edges labeled Follows:

MATCH (:User {name: 'Brainy'})-[:Follows]->*(u:User)
RETURN collect_list(u.name) AS names

Result:

Gets users who Brainy can reach by 1 or more outgoing edges labeled Follows:

MATCH (:User {name: 'Brainy'})-[:Follows]->+(u:User)
RETURN collect_list(u.name) AS names

Result:

Fixed Upperbound

Gets users who Brainy can reach by 0 to 2 edges labeled Follows:

MATCH (:User {name: 'Brainy'})-[:Follows]-{,2}(u:User)
RETURN collect_list(u.name) AS names

Result:

Quantified Abbreviated Edges

With an abbreviated edge pattern, there is no label and property restrictions on the edge. The following example gets users who Brainy can reach by 1 to 2 edges:

MATCH (:User {name: 'Brainy'})-{1,2}(u:User)
RETURN collect_list(u.name) AS names

Result:

Quantified Paths

Quantified paths are built by an parenthesized path pattern followed by a quantifier that specifies how many times the path repeats.

This path pattern expression is equivalent to:

At the transition between groups, two node patterns are concatenated consecutively. They are combined to a single node pattern with all filtering conditions merged conjunctively. In this example, this is straightforward since the only filtering applied is the User label:

With this, the above is simplified to:

Example Graph

The following examples run against this graph:

To create this graph, run the following query against an empty graph:

INSERT (jack:User {_id: "U01", name: "Jack"}),
       (mike:User {_id: "U02", name: "Mike"}),
       (c1:Device {_id: "Comp1"}),
       (c2:Device {_id: "Comp2"}),
       (c3:Device {_id: "Comp3"}),
       (c4:Device {_id: "Comp4"}),
       (jack)-[:Owns]->(c1),
       (mike)-[:Owns]->(c4),
       (c1)-[:Flows {packets: 20}]->(c2),
       (c1)-[:Flows {packets: 30}]->(c4),
       (c2)-[:Flows {packets: 34}]->(c3),
       (c2)-[:Flows {packets: 12}]->(c4),
       (c3)-[:Flows {packets: 74}]->(c4)

Fixed Lowerbound and Upperbound

Gets paths of 1 to 3 outgoing data flows from the device owned by Jack to the device owned by Mike, where each data flow has more than 15 packets:

MATCH p = (:User {name: 'Jack'})-[:Owns]->()
      ((:Device)-[f:Flows WHERE f.packets > 15]->(:Device)){1,3}
      ()<-[:Owns]-(:User {name: 'Mike'})
RETURN p

Result:

Fixed Length

Gets paths of 3 outgoing data flows from the device owned by Jack to the device owned by Mike, where each data flow has more than 15 packets:

MATCH p = (:User {name: 'Jack'})-[:Owns]->()
      ((:Device)-[f:Flows WHERE f.packets > 15]->(:Device)){3}
      ()<-[:Owns]-(:User {name: 'Mike'})
RETURN p

Result:

Fixed Lowerbound

Gets paths of 2 or more outgoing data flows from the device owned by Jack to the device owned by Mike, where each data flow has more than 15 packets:

MATCH p = (:User {name: 'Jack'})-[:Owns]->()
      ((:Device)-[f:Flows WHERE f.packets > 15]->(:Device)){2,}
      ()<-[:Owns]-(:User {name: 'Mike'})
RETURN p

Result:

Gets paths of 0 or more outgoing data flows from the device owned by Jack to the device owned by Mike, where each data flow has more than 15 packets:

MATCH p = (:User {name: 'Jack'})-[:Owns]->()
      ((:Device)-[f:Flows WHERE f.packets > 15]->(:Device))*
      ()<-[:Owns]-(:User {name: 'Mike'})
RETURN p

Result:

Gets paths of 1 or more outgoing data flows from the device owned by Jack to the device owned by Mike, where each data flow has more than 15 packets:

MATCH p = (:User {name: 'Jack'})-[:Owns]->()
      ((:Device)-[f:Flows WHERE f.packets > 15]->(:Device))+
      ()<-[:Owns]-(:User {name: 'Mike'})
RETURN p

Result:

Fixed Upperbound

Gets paths of 0 to 2 outgoing data flows from the device owned by Jack to the device owned by Mike, where each data flow has more than 15 packets:

MATCH p = (:User {name: 'Jack'})-[:Owns]->()
      ((:Device)-[f:Flows WHERE f.packets > 15]->(:Device)){,2}
      ()<-[:Owns]-(:User {name: 'Mike'})
RETURN p

Result:

Degree of Reference of Element Variables

If an element variable is declared in a quantified path pattern, then it may bind to more than one graph element. References to the element variable are interpreted contextually.

Singleton Degree of Reference

This feature is not yet supported.

If the reference occurs inside the quantified path pattern, then the reference has singleton degree of reference and references at most one graph element.

MATCH p = ((a)-[]->(b) WHERE a.age < b.age){1,2}
RETURN p

Result:

In this query, a and b are singletons that represent individual nodes. The condition a.age < b.age is evaluated for each pair of nodes a and b as the path is matched.

Group Degree of Reference

If the reference occurs outside the quantified path pattern, then the reference has group degree of reference and references to the complete list of graph elements. In this circumstance, the element variable is viewed as a group variable.

MATCH p = ((a)-[]->(b)){1,2}
RETURN p, a, b

Result:

Variables a and b are exposed as group variables in the RETURN statement. Each of them represents a list of nodes encountered along the matched paths, rather than a single node.

The following query throws syntax error since it treats a and b as singleton variables outside a quantified path pattern:

MATCH p = ((a)-[]->(b)){1,2}
WHERE a.age < b.age
RETURN p

The horizontal aggregation feature is not yet supported.

Group variables can be used to aggregate data along the quantified paths or edges, which is the horizontal aggregation.

MATCH p = ()-[e]->{1,2}()
WHERE sum(e.score) > 2
RETURN p, collect_list(e.score) AS scores

Result: