Cypher匹配不同深度的路径

Question

我有一个问题，我一直试图从我的Neo4j数据库中出现的某种情况中获取信息。这是节点配置。

我需要获取连接到a的所有节点以及我需要的所有传入连接，以查找传入的连接节点以及传出所有传出节点的传输。

所以我希望a，b，c，d，l，f和e。不是g，h，i，j和k。

我尝试过什么我没有在一个查询中获得完整的集合。我或多或少或多或少。

MATCH (n)-[r]-(m) WHERE n.name="a"
RETURN n,m,r

仅提供a，b，c，f和l。

MATCH (n)-[r]-(m)-[s]->(x)
WHERE n.name="a"
RETURN n,m,r,s,x

，然后我丢失了b和l。

所以我一定做错了。是否有查询可以获取我需要的数据？

Answer 1

考虑此初始数据集（打印屏幕中显示的数据模型）：

@ViewChild('v') v;

ngAfterViewInit() {
console.log(this.v);
}

此查询应该有效：

CREATE (a:Node {name : 'a'})
CREATE (b:Node {name : 'b'})
CREATE (c:Node {name : 'c'})
CREATE (d:Node {name : 'd'})
CREATE (e:Node {name : 'e'})
CREATE (f:Node {name : 'f'})
CREATE (g:Node {name : 'g'})
CREATE (h:Node {name : 'h'})
CREATE (i:Node {name : 'i'})
CREATE (j:Node {name : 'j'})
CREATE (k:Node {name : 'k'})
CREATE (l:Node {name : 'l'})

CREATE (a)-[:CONNECTED_TO]->(c)
CREATE (c)-[:CONNECTED_TO]->(d)
CREATE (a)-[:CONNECTED_TO]->(l)
CREATE (b)-[:CONNECTED_TO]->(a)
CREATE (a)-[:CONNECTED_TO]->(f)
CREATE (f)-[:CONNECTED_TO]->(e)
CREATE (g)-[:CONNECTED_TO]->(f)
CREATE (i)-[:CONNECTED_TO]->(g)
CREATE (i)-[:CONNECTED_TO]->(h)
CREATE (i)-[:CONNECTED_TO]->(j)
CREATE (j)-[:CONNECTED_TO]->(k)

结果将是：

// Match de start point 'A'
MATCH (a:Node {name : 'a'})
// Match incoming nodes and optionally (0..1) incoming of incoming nodes
MATCH (a)<-[:CONNECTED_TO]-(b:Node)<-[:CONNECTED_TO*0..1]-(c:Node)
// collect b and c into rows, pass a to the next context
WITH a, collect(b) + collect(c) as rows
// Match outgoing nodes and optionally (0..1) outgoing of outgoing nodes
MATCH (a)-[:CONNECTED_TO]->(b:Node)-[:CONNECTED_TO*0..1]->(c:Node)
// collect all into rows
WITH collect(a) + collect(b) + collect(c) + rows as rows
// unwind 
UNWIND rows AS unwinded
// return distinct nodes
RETURN DISTINCT unwinded
ORDER BY unwinded.name

修改

重构查询：

╒════════════╕
│"unwinded"  │
╞════════════╡
│{"name":"a"}│
├────────────┤
│{"name":"b"}│
├────────────┤
│{"name":"c"}│
├────────────┤
│{"name":"d"}│
├────────────┤
│{"name":"e"}│
├────────────┤
│{"name":"f"}│
├────────────┤
│{"name":"l"}│
└────────────┘

上述查询会产生相同的结果，但整个模式只使用一个MATCH (in2:Node)-[:CONNECTED_TO*0..1]->(in:Node)-[:CONNECTED_TO]->(a:Node {name : 'a'})-[:CONNECTED_TO]->(out:Node)-[:CONNECTED_TO*0..1]->(out2:Node) WITH collect(in2) + collect(in) + collect(a) + collect(out) + collect(out2) as rows UNWIND rows AS unwinded RETURN distinct unwinded ORDER BY unwinded.name 而不是3个不同的MATCH es。