密码查询返回或仅保留使用可变长度关系标识符时的最终序列

Question

当使用变量长度标识符进行更深层次的操作时，是否有方法保留或仅返回最终的全部节点序列而不是所有子路径每个最终全序列路径上的操作。

MATCH路径=（S：人） - [RELS：NEXT *] - >（E：人）................

例如：找到所有在给定列表中具有其名称的节点序列，比如['graph'，'server'，'db']具有相同的'seqid'属性。

即

（图形） - >（服务器） - （分贝）与相同SEQID：1

（图形） - >（分贝） - >（服务器）具有相同SEQID：1 //可以有另一个匹配
序列具有相同SEQID

（图） - >（DB） - >（服务器）具有相同的SEQID：2

有没有办法只保留节点的最终序列说'（图） - >（服务器） - >（db）'代替每个序列>（服务器）或（服务器） - - 样（图）大序列的子路径>（DB）

请帮助我解决这个.........

（我在嵌入模式下使用neo4j 2.3.6社区版通过java api ..）

Answer 1

我们真的可以在这里使用的是一个longestSequences（）函数，它可以完成您想要的操作，扩展模式，使a和b将始终与序列中的开始点和结束点匹配，以使模式不是任何其他匹配模式的子集。

我创建正是这种对Neo4j的功能要求：https://github.com/neo4j/neo4j/issues/7760

而且直到得到实施，我们将不得不凑合着用一些替代方法。我认为我们要做的就是添加额外的匹配，将a和b限制为完整序列的开始和结束节点。

这是我提出的查询：

WITH ['graph', 'server' ,'db'] as names 
MATCH p=(a)-[rels:NEXT*]->(b) 
WHERE ALL(n in nodes(p) WHERE n.name in names) 
AND ALL(r in rels WHERE rels[0]['seqid'] = r.seqid) 
WITH names, p, a, rels, b 
// check if b is a subsequence node instead of an end node 
OPTIONAL MATCH (b)-[rel:NEXT]->(c) 
WHERE c.name in names 
AND rel.seqid = rels[0]['seqid'] 
// remove any existing matches where b is a subsequence node 
WITH names, p, a, rels, b, c 
WHERE c IS NULL 
WITH names, p, a, rels, b 
// check if a is a subsequence node instead of a start node 
OPTIONAL MATCH (d)-[rel:NEXT]->(a) 
WHERE d.name in names 
AND rel.seqid = rels[0]['seqid'] 
// remove any existing matches where a is a subsequence node 
WITH p, a, b, d 
WHERE d IS NULL 
RETURN p, a as startNode, b as endNode 

Answer 2

将帖子

此查询可能会做你想要什么：

MATCH (p1:Person)-[rel:NEXT]->(:Person) 
WHERE NOT (:Person)-[:NEXT {seqid: rel.seqid}]->(p1) 
WITH DISTINCT p1, rel.seqid AS seqid 
MATCH path = (p1)-[:NEXT* {seqid: seqid}]->(p2:Person) 
WHERE NOT (p2)-[:NEXT {seqid: seqid}]->(:Person) 
RETURN path; 

它首先识别所有Person节点（p1）至少一个传出NEXT的关系，没有传入NEXT关系（与seqid相同），和他们明显的传出seqid值。然后，它从每个p1节点开始并且具有全部共享相同seqid的关系，找到所有“完整”路径（即其开始和结束节点分别与期望的seqid没有呼入或呼出关系的路径）。最后，它返回每个完整的路径。

如果你只是想获得的所有Person节点的name财产的每个路径，尝试此查询（用不同的RETURN条款）：

MATCH (p1:Person)-[rel:NEXT]->(:Person) 
WHERE NOT (:Person)-[:NEXT {seqid: rel.seqid}]->(p1) 
WITH DISTINCT p1, rel.seqid AS seqid 
MATCH path = (p1)-[:NEXT* {seqid: seqid}]->(p2:Person) 
WHERE NOT (p2)-[:NEXT {seqid: seqid}]->(:Person) 
RETURN EXTRACT(n IN NODES(path) | n.name); 

Answer 3

MATCH (S:Person)-[r:NEXT]->(:Person) 
    // Possible starting node 
    WHERE NOT ((:Person)-[:NEXT {seqid: r.seqid}]->(S)) 
WITH S, 
    // Collect all possible values of `seqid` 
    collect (distinct r.seqid) as seqids 
UNWIND seqids as seqid 
// Possible terminal node 
MATCH (:Person)-[r:NEXT {seqid: seqid}]->(E:Person) 
    WHERE NOT ((E)-[:NEXT {seqid: seqid}]->(:Person)) 
WITH S, 
    seqid, 
    collect(distinct E) as ES 
UNWIND ES as E 
    MATCH path = (S)-[rels:NEXT* {seqid: seqid}]->(E) 
RETURN S, 
     seqid, 
     path