Neo4j: Transitive query and node ordering

Question

I am using Neo4j to track relationships in OOP architecture. Let us assume that nodes represent classes and (u) -[:EXTENDS]-> (v) if class u extends class v (i.e. for each node there is at most one outgoing edge of type EXTENDS). I am trying to find out a chain of predecessor classes for a given class (n). I have used the following Cypher query:

start n=node(...)
match (n) -[:EXTENDS*]-> (m)
return m.className

I need to process nodes in such an order that the direct predecessor of class n comes first, its predecessor comes as second etc. It seems that the Neo4j engine returns the nodes in exactly this order (given the above query) - is this something I should rely on or could this behavior suddenly change in some of the future releases?

If I should not rely on this behavior, what Cypher query would allow me to get all predecessor nodes in given ordering? I was thinking about following query:

start n=node(...)
match p = (n) -[:EXTENDS*]-> (m {className: 'Object'})
return p

Which would work quite fine, but I would like to avoid specifying the root class (Object in this case).

Btw. if you are interested in this you should check out github.com/buschmais/jqassistant which does exactly that and much more based on Neo4j & Cypher. — Michael Hunger

BtySgtMajor BtySgtMajor · Accepted Answer · 2014-07-08T20:16:57

It's unlikely to change anytime soon as this is really the nature of graph databases at work.

The query you've written will return ALL possible "paths" of nodes that match that pattern. But given that you've specified that there is at most one :EXTENDS edge from each such node, the order is implied with the direction you've included in the query.

In other words, what's returned won't start "skipping" nodes in a chain.

What it will do, though, is give you all "sub-paths" of a path. That is, assuming you specified you wanted the predecessors for node "a", for the following path...

(a)-[:EXTENDS]->(b)-[:EXTENDS]->(c)

...your query (omitting the property name) will return "a, b, c" and "a, b". If you only want ALL of its predecessors, and you can use Cypher 2.x, consider using the "path" way, something like:

MATCH p = (a)-[:EXTENDS*]->(b)
WITH p
ORDER BY length(p) DESC
LIMIT 1
RETURN extract(x in nodes(p) | p.className)

Also, as a best practice, given that you're looking at paths of indefinite length, you should likely limit the number of hops your query makes to something reasonable, e.g.

MATCH (n) -[:EXTENDS*0..10]-> (m)

Or some such.

HTH

Neo4j: Transitive query and node ordering

1 Answers