如何编写Cypher查询递归遍历Neo4j图以查找所有依赖节点

图结构创建代码 #

首先是创建图的Cypher语句：

create (a:Account{name:'account.a'}),
(b:Account{name:'account.b'}),
(c:Account{name:'account.c'}),
(d:Account{name:'account.d'}),
(e:Account{name:'account.e'}),
(f:Account{name:'account.f'}),
(x:Account{name:'account.x'}),
(y:Account{name:'account.y'}),
(cas:Calculation{name:'account.a:simple_interest'}),
(cac:Calculation{name:'account.a:compound_interest'}),
(cbs:Calculation{name:'account.b:simple_interest'}),
(cbc:Calculation{name:'account.b:compound_interest'}),
(cxs:Calculation{name:'account.x:simple_interest'}),
(cxc:Calculation{name:'account.x:compound_interest'}),
(a)-[:RESULTS_FROM]->(cas),
(a)-[:RESULTS_FROM]->(cac),
(b)-[:RESULTS_FROM]->(cbs),
(b)-[:RESULTS_FROM]->(cbc),
(x)-[:RESULTS_FROM]->(cxs),
(x)-[:RESULTS_FROM]->(cxc),
(cas)-[:DEPENDS_ON]->(d),
(cas)-[:DEPENDS_ON]->(e),
(cbs)-[:DEPENDS_ON]->(c),
(cbc)-[:DEPENDS_ON]->(y),
(cac)-[:DEPENDS_ON]->(f),
(cac)-[:DEPENDS_ON]->(d),
(cxs)-[:DEPENDS_ON]->(d),
(cxc)-[:DEPENDS_ON]->(d)

需求说明 #

图中包含两种节点：

• Account：通过RESULTS_FROM关系关联到对应的Calculation节点（命名规则为账号名:利息类型）
• Calculation：通过DEPENDS_ON关系关联其他Account节点

需要编写Cypher查询，从指定Account节点出发，递归遍历整个图，找到所有最终依赖的Account节点：

1. 路径规则：Account →[:RESULTS_FROM]→ Calculation →[:DEPENDS_ON]→ Account，重复此过程
2. 终止条件：遍历到没有RESULTS_FROM关系的Account节点为止
3. 示例：
   • 从account.b出发，输出account.y和account.c
   • 从account.x出发，输出account.d

你的尝试分析 #

你提供的查询存在两个关键问题：

1. 未区分关系类型：MATCH (node)-[r]->(relatedNode)会遍历所有出边，不符合仅遍历RESULTS_FROM和DEPENDS_ON的要求
2. 递归逻辑无效：FOREACH内部的SET无法修改外部的nodes变量，无法实现真正的递归遍历

最优解决方案 #

方案1：原生可变长度路径匹配（简洁高效） #

利用Neo4j的可变长度路径匹配，直接匹配符合规则的所有依赖路径，再过滤出最终的叶子Account节点：

// 替换为你要查询的起始Account名称
MATCH (start:Account {name: 'account.b'})
// 匹配所有符合规则的依赖路径：Account→RESULTS_FROM+→Calculation→DEPENDS_ON+→Account
MATCH (start)-[:RESULTS_FROM+]->(:Calculation)-[:DEPENDS_ON+]->(dependency:Account)
// 过滤出没有RESULTS_FROM关系的最终依赖Account
WHERE NOT EXISTS ((dependency)-[:RESULTS_FROM]->())
// 返回去重后的依赖账号名称
RETURN DISTINCT dependency.name AS dependentAccounts

方案2：递归CTE（适用于复杂遍历逻辑） #

如果需要更灵活的递归控制，可使用Neo4j的递归公用表表达式：

// 替换为你要查询的起始Account名称
MATCH (start:Account {name: 'account.b'})
WITH start

// 初始化递归集合：获取起始节点的直接依赖Account
MATCH (start)-[:RESULTS_FROM]->(calc:Calculation)-[:DEPENDS_ON]->(dep:Account)
WITH collect(DISTINCT dep) AS accounts

// 递归遍历，直到没有新的依赖Account
CALL {
  WITH accounts
  UNWIND accounts AS acc
  // 查找当前Account的间接依赖
  MATCH (acc)-[:RESULTS_FROM]->(calc:Calculation)-[:DEPENDS_ON]->(newDep:Account)
  WHERE NOT newDep IN accounts
  RETURN collect(DISTINCT newDep) AS newAccounts
  UNION ALL
  // 没有新节点时返回空集合
  RETURN [] AS newAccounts
}
WHILE size(newAccounts) > 0
  SET accounts = accounts + newAccounts
  CALL {
    WITH accounts
    UNWIND accounts AS acc
    MATCH (acc)-[:RESULTS_FROM]->(calc:Calculation)-[:DEPENDS_ON]->(newDep:Account)
    WHERE NOT newDep IN accounts
    RETURN collect(DISTINCT newDep) AS newAccounts
    UNION ALL
    RETURN [] AS newAccounts
  }

// 过滤并返回最终的依赖Account
WITH accounts
UNWIND accounts AS acc
WHERE NOT EXISTS ((acc)-[:RESULTS_FROM]->())
RETURN DISTINCT acc.name AS dependentAccounts

这两种方案都能高效处理上百个节点的规模，方案1更简洁，适合当前固定的关系规则；方案2更灵活，可应对后续规则变化。

内容的提问来源于stack exchange，提问作者Naxi