Select single directed acyclic graph - neo4j

Question

I'm new to neo4j and I'm trying to extract a single, directed acyclic subgraph from from a graph in such a way as to be able to iterate over the resulting graph (or the collection of nodes and paths) and keep track of layers in which each node would reside (where layers are based on the number of hops from the nearest root node). Is this possible in cypher? I'm using the REST api.
The example datastructure I have is something like the following subgraph, where A and H would be the 'root' nodes:
A -+ B -+ D
|
+
H -+ C -+ E
|
+
F
S*
B and C would each be layer 1 and D, E, F would be layer 2. A and H have a :SUBGRAPH_ENTER relation to S* and all nodes in the subgraph I want have the relation :MEMBER_OF_SUBGRAPH to S*
The following query will return the subgraph (piecemeal) I want, however, I'm not sure how to go about ordering the nodes in the paths.
MATCH p = (n)-[r:ARROW_TO*]-(t)-[:SUBGRAPH_ENTER]-(s)
where
(n)-[:MEMBER_OF_SUBGRAPH]->(s)
RETURN p
Can anyone advise?

Answer 1

[EDITED]
If you create your sample acyclic graph with these 2 queries:
CREATE (s:Subgraph),
(a:Foo {id:'A'}), (b:Foo {id:'B'}), (c:Foo {id:'C'}), (d:Foo {id:'D'}), (e:Foo {id:'E'}), (f:Foo {id:'F'}), (h:Foo {id:'H'}),
(a)-[:ARROW_TO]->(b)-[:ARROW_TO]->(d),
(h)-[:ARROW_TO]->(c)-[:ARROW_TO]->(e),
(b)-[:ARROW_TO]->(c)-[:ARROW_TO]->(f),
(a)<-[:SUBGRAPH_ENTER]-(s),
(h)<-[:SUBGRAPH_ENTER]-(s);
MATCH (f:Foo), (s:Subgraph)
CREATE (f)-[:MEMBER_OF_SUBGRAPH]->(s);
then this query will return the subgraph nodes, ordered by distance from the nearest root:
MATCH p=(s)-[:SUBGRAPH_ENTER]->(root)-[:ARROW_TO*]->(leaf)
WHERE (NOT (leaf)-[:ARROW_TO]->()) AND ALL(n IN NODES(p)[1..] WHERE (n)-[:MEMBER_OF_SUBGRAPH]->(s))
WITH s, NODES(p)[2..] AS nodes
WITH s, REDUCE(s = [], i IN RANGE(0, SIZE(nodes)-1) | s + {node: nodes[i], dist: i+1}) AS data
UNWIND data AS datum
RETURN s, datum.node AS node, MIN(datum.dist) AS distance
ORDER BY distance;
The WHERE clause filters out paths that are partial or have nodes from other subgraphs.
The first WITH clause collects the nodes in each path starting after the root node.
The second WITH clause generates a collection of node/distance pairs for each node in the first collection.
The UNWIND transforms the latter collection into data rows, for processing by the MIN aggregation function.
Here are the results:
+------------------------------------------+
| s | node | distance |
+------------------------------------------+
| Node[38]{} | Node[41]{id:"C"} | 1 |
| Node[38]{} | Node[40]{id:"B"} | 1 |
| Node[38]{} | Node[44]{id:"F"} | 2 |
| Node[38]{} | Node[43]{id:"E"} | 2 |
| Node[38]{} | Node[42]{id:"D"} | 2 |
+------------------------------------------+
Including the root nodes
If you want to include the root nodes in the output, this query will do that:
MATCH p=(s)-[:SUBGRAPH_ENTER]->(root)-[:ARROW_TO*]->(leaf)
WHERE (NOT (leaf)-[:ARROW_TO]->()) AND ALL (n IN NODES(p)[1..] WHERE (n)-[:MEMBER_OF_SUBGRAPH]->(s))
WITH s, NODES(p)[1..] AS nodes
WITH s, REDUCE(s =[], i IN RANGE(0, SIZE(nodes)-1)| s + { node: nodes[i], dist: i }) AS data
UNWIND data AS datum
RETURN s, datum.node AS node, MIN(datum.dist) AS distance
ORDER BY distance;
Here are the results:
+-----------------------------------------+
| s | node | distance |
+-----------------------------------------+
| Node[6]{} | Node[7]{id:"A"} | 0 |
| Node[6]{} | Node[13]{id:"H"} | 0 |
| Node[6]{} | Node[8]{id:"B"} | 1 |
| Node[6]{} | Node[9]{id:"C"} | 1 |
| Node[6]{} | Node[10]{id:"D"} | 2 |
| Node[6]{} | Node[12]{id:"F"} | 2 |
| Node[6]{} | Node[11]{id:"E"} | 2 |
+-----------------------------------------+