java过滤路径../_Neo4J / Cypher：如何过滤路径的节点？

你尝试过使用filter()或none()吗？我想我正确地理解了你的问题，但这就是我如何使用上述功能 . (如果这是关闭的，只需要下来 . )

CREATE

(g:Person {name: 'Gorduin'}), (a:Person {name: 'Alvaro'}),

(pn:PhoneNumber {number: '555-512-2017'}),

(e11:Extension {extension: 11}),

(e27:Extension {extension: 27}),

(e19:Extension {extension: 19}),

(e11)-[:extension_of]->(pn)

(e19)-[:extension_of]->(pn),

(g)

(g)

(a)

(a)

需要使用可变长度查询，因为 :phone_number_of 指针可以来自扩展名(链接到电话号码)或电话号码本身 . 箭头方向无关紧要，您可以撤消其中任何一个并尝试以下查询 .

(在我的情况下，限制查询的长度将是显而易见的解决方案，例如MATCH path =(p：Person) - [* 1..3] - (n：PhoneNumber)

RETURN节点(路径);

但这不是OP的问题 . )

(1)获取从人到电话号码的每条可能路径(为便于阅读而编辑)：

MATCH path = (p:Person)-[*]-(n:PhoneNumber)

RETURN nodes(path) as every_possible_path_from_a_Person_to_a_PhoneNumber;

╒══════════════════════════════════════════════════════════════════════╕

│"every_possible_path_from_a_Person_to_a_PhoneNumber" │

╞══════════════════════════════════════════════════════════════════════╡

│[a,pn] │

├──────────────────────────────────────────────────────────────────────┤

│[g,e11,pn,e19,a,pn] │

├──────────────────────────────────────────────────────────────────────┤

│[g,e27,pn,e19,a,pn] │

├──────────────────────────────────────────────────────────────────────┤

│[g,e11,pn] │

├──────────────────────────────────────────────────────────────────────┤

│[a,pn,e27,g,e11,pn] │

├──────────────────────────────────────────────────────────────────────┤

│[a,e19,pn,e27,g,e11,pn] │

├──────────────────────────────────────────────────────────────────────┤

│[a,e19,pn] │

├──────────────────────────────────────────────────────────────────────┤

│[g,e11,pn,a,e19,pn] │

├──────────────────────────────────────────────────────────────────────┤

│[g,e27,pn,a,e19,pn] │

├──────────────────────────────────────────────────────────────────────┤

│[g,e27,pn] │

├──────────────────────────────────────────────────────────────────────┤

│[a,pn,e11,g,e27,pn] │

├──────────────────────────────────────────────────────────────────────┤

│[a,e19,pn,e11,g,e27,pn] │

└──────────────────────────────────────────────────────────────────────┘

(2)使用 none() 通过过滤掉包含特定节点(具有特定属性或标签的节点)的路径来删除冗余：

MATCH path = (p:Person)-[*]-(n:PhoneNumber)

WITH nodes(path) as ns

WHERE NONE(node IN ns WHERE (exists(node.name) and node.name ='Gorduin'))

RETURN ns as path_nodes_NOT_containing_a_specific_person;

╒══════════════════════════════════════════════════════════════╕

│"path_nodes_NOT_containing_a_specific_person" │

╞══════════════════════════════════════════════════════════════╡

│[a,pn] │

├──────────────────────────────────────────────────────────────┤

│[a,e19,pn] │

└──────────────────────────────────────────────────────────────┘

(3)使用 filter() 从返回的路径中删除特定节点：

MATCH path = (p:Person)-[*]-(n:PhoneNumber)

WITH nodes(path) as ns

WHERE NONE(node IN ns WHERE (exists(node.name) and node.name ='Gorduin'))

RETURN filter(node in ns WHERE NOT node:Person) as personless_nodelist;

╒══════════════════════════════════════════════════════════════╕

│"personless_nodelist" │

╞══════════════════════════════════════════════════════════════╡

│[pn] │

├──────────────────────────────────────────────────────────────┤

│[e19,pn] │

└──────────────────────────────────────────────────────────────┘