Now I understand. You would like to count the relationships for each node along your subgraph to only nodes that are elements of your subgraph. This turned out to be tricky, because your match results in a list of paths and you want to process collection as paths as one subgraph. I achieved this by using a reduce operation on the individual paths to get a consolidate list of nodes along all the resulting paths from your match statement. The list contains duplicates, which I was not able to remove until the very end, so there is a little bit if inefficiency, as the nodes common to more than one path get processed multiple times. The results are correct even so. I then calculated the number of relationships for each node on your subgraph, but limited the count to only relationships with other nodes on the subgraph. I was able to get the counts you want.
match p=((a:label {Name:'Pro7'})-[*4]->(b:label {Name:'Pro1'}))
with reduce(s=, i in collect(nodes(p)) | i + s) as allSubGraphNodes
unwind allSubGraphNodes as node
call {
with node, allSubGraphNodes
match(c)--(node)
where (c in allSubGraphNodes)
return count(c) as count
}
return distinct node, count
here is the output I got:
No worries, I am also learning neo4j. I wrote an application using a relational DBMS, but naturally fits a graph database, so I got excited when I learned of neo4j. I am in the process of replatforming it.
Cypher basically pattern matches. Each result row is a match of your pattern. In your case, your match statement below finds two paths that match.
match p=((a:label {Name:'Pro7'})-[*4]->(b:label {Name:'Pro1'}))
The Neo4j Browser view of the result shows the matching nodes and renders them with all the relationships, so it looks like the result is a subgraph. The actual results of the query are shown under the text or table views. As you can see below, the result consist of two paths.
It is easy to count the number of relationships ingoing/outgoing from a node with the query below:
match(n{key:value})
match(n)-(c)
return count(c)
In your case, you wanted to restrict the relationship count to only those relationships that are part of your query results. Assuming allSubGraphNodes is a list of those nodes resulting from your query, you can modify the above query to restrict the count to just those relationships between the allSubGraphNodes:
match(n{key:value})
match(n)-(c)
where (c in allSubGraphNodes)
return count(c)
To get this to work for your case, we need to take the query results that consists of two separate paths, and convert them into a single list of all the nodes along either path. That is the goal of the following part of the query:
match p=((a:label {Name:'Pro7'})-[*4]->(b:label {Name:'Pro1'}))
with reduce(s=, i in collect(nodes(p)) | i + s) as allSubGraphNodes
To process the list of allSubGraphNodes through the query part that counts the relationships per node, we need to convert the list into rows using the UNWIND clause, then pass the rows and the list of allSubGraphNodes to the next phase of the query using the WITH clause. The DISTINCT clause removes the duplicate nodes that are in multiple paths. That is what this part of the query does:
unwind allSubGraphNodes as node
with distinct node, allSubGraphNodes
To answer your question specifically, it is the WITH clause that allows you to chain query results to form a query pipeline to formulate the final result you want .
You can also execute subqueries using the CALL clause. This allows you to execute a full cypher query block for each row of the outer query's result. The subquery's result will be added to the outer query's result. The subquery can result in zero, one, or N results. If zero, the query will stop. If one, then the one result will be added to the outer query result. If N, then each subquery result will be added to the outer query's result N times. This is done on a per outer query result row. BTW- the subquery can be either to perform more querying to augment the outer query (similar to a join in SQL), or it can be to perform a mutation operation, such as creating new nodes based on the outer query result.
As discussed, cypher results in collections of paths for its results. If this doesn't work for your requirements and you want to work with subgraphs, then you may consider two alternatives. First, you can use one of the client drivers to iteratively walk the subgraph to formulate your subgraph for additional processing. You would do this by getting your root node, then get the child nodes through the root node's relationships. You can continue this process iteratively until you reach the terminal nodes of your subgraph. You can program an iterative algorithm and execute it in one ReadTransaction.
If this is something you do often and performance is an issue, you can consider writing a custom procedure using the neo4j Java API to run the algorithm on the server itself. You would then call the procedure in cypher. For example, you would match the root node in cypher and in the same query, send that node to your procedure and get back your processed subgraph. I have done this for a project I am working on, so if you want to get jumpstarted I would be happy to help. It took me a while to wade through the documentation and get it working. I now have a nice working platform to development and unit test.
Thank you for the detailed explanation. First I have to try your solution in other examples to completely understand it and then do the next step 
.
It will be much easier if there will be a native Neo4j function (maybe exists but I don't know for it) to transform the path into a graph ... something like
MATCH p=(....)
WITH to_graph(p) AS newgraph
MATCH (...)
so the second MATCH will match the pattern in the newgraph
Thank you
Regards
NODES 2022, Neo4j Online Education Summit
All the sessions of the conference are now available online
