Neo4j 提取按关系排序的图路径中的节点

我的任务是找到一条路径并处理其中的节点，尊重它们在同一路径中的顺序（因此顺序是关系诱导的）

给定具有以下节点的图形：

CREATE (a:temporary {name: 'm2'});
CREATE (a:temporary {name: 'f1'});
CREATE (a:temporary {name: 'b3'});
CREATE (a:temporary {name: 'd4'});

CREATE (a:temporary {name: 'p5'});
CREATE (a:temporary {name: 'p6'});
CREATE (a:temporary {name: 'p7'});

CREATE (a:temporary {name: 'k1'});
CREATE (a:temporary {name: 'k2'});

以及以下关系：

MATCH (a) WHERE a.name = 'b3' MATCH (b) where b.name = 'm2' CREATE (a)-[:KNOWS {type: 'sibling'}]->(b);
MATCH (a) WHERE a.name = 'm2' MATCH (b) where b.name = 'f1' CREATE (a)-[:KNOWS {type: 'friend'}]->(b);
MATCH (a) WHERE a.name = 'd4' MATCH (b) where b.name = 'b3' CREATE (a)-[:KNOWS {type: 'coworker'}]->(b);

MATCH (a) WHERE a.name = 'p7' MATCH (b) where b.name = 'p6' CREATE (a)-[:KNOWS {type: 'friend'}]->(b);
MATCH (a) WHERE a.name = 'p6' MATCH (b) where b.name = 'p5' CREATE (a)-[:KNOWS {type: 'coworker'}]->(b);

MATCH (a) WHERE a.name = 'k1' MATCH (b) where b.name = 'b3' CREATE (a)-[:HAS]->(b);
MATCH (a) WHERE a.name = 'k1' MATCH (b) where b.name = 'd4' CREATE (a)-[:HAS]->(b);
MATCH (a) WHERE a.name = 'k1' MATCH (b) where b.name = 'm2' CREATE (a)-[:HAS]->(b);
MATCH (a) WHERE a.name = 'k1' MATCH (b) where b.name = 'f1' CREATE (a)-[:HAS]->(b);

MATCH (a) WHERE a.name = 'k2' MATCH (b) where b.name = 'p5' CREATE (a)-[:HAS]->(b);
MATCH (a) WHERE a.name = 'k2' MATCH (b) where b.name = 'p7' CREATE (a)-[:HAS]->(b);
MATCH (a) WHERE a.name = 'k2' MATCH (b) where b.name = 'p6' CREATE (a)-[:HAS]->(b);

创建顺序很重要，因为我看到Neo4j在没有其他顺序的情况下按id对结果进行排序，这可以给出一个提示：当发出的查询错误时，节点以错误的顺序返回

您应该提供以下图形表示：

我需要按照

knows

给出的顺序提取

k1

拥有的节点（并且只有那些节点），以便：

f1 <- m2 <- b3 <- d4

---

更新 经过一些尝试，我提出了以下两个问题

(一)

这条路径的结果是一条真正的路径——尽管中间节点是重复的，即

。。。{“type”：“coworker”}、{“name”：“b3”}、{“name”：“b3”}、{“type”：“sibling”}……

，我不知道这是设计造成的还是我犯了错误-，返回的结果只有一个，其元素顺序正确（虽然它从尾部开始，但我想在程序中很容易处理），从图形来看，感觉更“自然”，而且更安全（在图形随着使用量的增加而增加之后，不会出现错误的风险）：

(二)

相反，这会以我想要的形状给出结果（成对的（节点，关系）-忽略

s

列，它只是在那里检查它的值），尽管事实上找到了几个路径（所有路径都来自

k1

所知的组中的每个节点，它们都指向头部

f1

）我需要操纵它们中的每一个，将一个节点与其最近的关系配对，并将结果从最靠近头部到最远的顺序排列）：

---

到目前为止，我还不能用它来判断使用的是正确的。

我正在努力找出您遇到的问题。到目前为止你试过什么？结果如何？您的代码有什么问题？你的预期结果是什么？——在发表这篇文章时，我没有任何接近甚至部分结果的东西。后来我设法获得了两个查询，我在这里添加了它们。请看我的编辑。

for x in [result] do:
    if(x.type.isEmpty) {
        // process the head
    } else if (x.type == "friend") {
        // do something knowing this node is a friend of the preceding one
    } else ...

match p=(a:temporary)-[:KNOWS*0..]->(b) 
where not ()-[:KNOWS]->(a) and not (b)-[:KNOWS]->() 
and exists { match (k)-[:HAS]->(a) where k.name='k1' } 
return p

╒══════════════════════════════════════════════════════════════════════╕
│"p"                                                                   │
╞══════════════════════════════════════════════════════════════════════╡
│[{"name":"d4"},{"type":"coworker"},{"name":"b3"},{"name":"b3"},{"type"│
│:"sibling"},{"name":"m2"},{"name":"m2"},{"type":"friend"},{"name":"f1"│
│}]                                                                    │
└──────────────────────────────────────────────────────────────────────┘

match p=(a)-[:KNOWS*0..]->(b)
where 
not (b)-[:KNOWS]->()
and exists { match (k)-[:HAS]->(a) where k.name='k1' }
with  a, head(relationships(p)) as h, size(relationships(p)) as s
return a, h, s
order by s

╒═════════════╤═══════════════════╤═══╕
│"a"          │"h"                │"s"│
╞═════════════╪═══════════════════╪═══╡
│{"name":"f1"}│null               │0  │
├─────────────┼───────────────────┼───┤
│{"name":"m2"}│{"type":"friend"}  │1  │
├─────────────┼───────────────────┼───┤
│{"name":"b3"}│{"type":"sibling"} │2  │
├─────────────┼───────────────────┼───┤
│{"name":"d4"}│{"type":"coworker"}│3  │
└─────────────┴───────────────────┴───┘