How to partially isolate a subgraph without using labels in neo4j

Question

I'm creating a graph that contains a large number of subgraphs of roughly treelike structure in that the 'root' of each subgraph only has outwardly directed relationships. The many leaves and branches of this subgraph all contain data related to the root. This is so that a single query like the following will return all data associated with a given root, and only the data associated with that root:

MATCH (root:ROOT {id: 'foo'})-[*]->(leaves) RETURN leaves

There are very strong reasons to optimize for this query. However, the subgraphs are not truly isolated, because some of the leaves are actually categories that can receive relationships from many roots, so structures like this exist:

(root)-[]->(category)<-[]-(root)

This seems like a great way to preserve the integrity of the subgraphs while also allowing for complex relationships between them, however, there's one catch. I can't have simple, one-to-one relationships directly between roots, or one root will contaminate the other's response to the first query. As I see it, there are only two real options.

1. Build a new dummy node for each 1-to-1 relationship between roots. Like so:

   (root)-[]->(dummy)<-[]-(root)

   I hate this option. It proliferates useless nodes and it dilutes the concept of relationships.

2. Give every child of each subgraph a label identifying it as a member of the subgraph. This is an even worse option as I see it. Since the subgraphs number in the many thousands it would dramatically pollute the label space.

I've also considered filtering on the label of a direct relationship, but that only excludes the foreign root, and not its children. See below:

Filter on the label of direct 1-to-1 relationships with a structure like this:

(root)-[:bar]->(foreign_root)-[]->(foreign_leaves)

And a primary query like this:

MATCH (root {id: 'foo'})-[*]->(leaves) WHERE NOT (root)-[:bar]->(leaves) RETURN leaves

Produces a result of (foreign_leaves) This is undesirable for multiple reasons, since it makes the most important query larger, and doesn't actually isolate the graph.

So, in one sense I am asking, is there a way to create a direct, 1-to-1 relationship between two of these roots without massive graph pollution or cross-contamination between subgraphs? In a larger sense, am I viewing the problem wrongly?

Answer 1

I think you are almost there. In your last Cypher query, you can tweak your WHERE clause so that it does not instantiate the :bar relationship's destination node. Like this:

MATCH (root {id: 'foo'})-[*]->(leaves)
WHERE NOT (root)-[:bar]->()
RETURN leaves

This way, you filter out all paths that start with a :bar relationship.