使用递归查询查找子树：Neo4j节点筛选需求

图谱结构 #

A
            ____|_____
        (1)/ (2)|  (3)\
          AA    AB    AC
       ____|____
   (1)/ (2)| (3)\
    AAA   AAB   AAC

数据创建语句 #

create
  (a:Node {title:"A", ordered:false, active: true}),
  (aa:Node {title:"AA", ordered: true, active: true}),
  (ab:Node {title:"AB", ordered: false, active: true}),
  (ac:Node {title:"AC", ordered: false, active: false}),
  (aaa:Node {title:"AAA", ordered: false, active: true}),
  (aab:Node {title:"AAB", ordered: false, active: true}),
  (aac:Node {title:"AAC", ordered: false, active: true}),
  (a)-[:RELATED_WITH { order: 1 }]->(aa),
  (a)-[:RELATED_WITH { order: 2 }]->(ab),
  (a)-[:RELATED_WITH { order: 3 }]->(ac),
  (aa)-[:RELATED_WITH{ order: 1 }]->(aaa),
  (aa)-[:RELATED_WITH{ order: 2 }]->(aab),
  (aa)-[:RELATED_WITH{ order: 3 }]->(aac)
return *;

查询需求 #

给定起始节点（例如"A"），需查找所有子节点，但需满足以下规则：

• 仅能遍历至active=true的节点；
• 若节点的ordered=true属性被设置，则仅需遍历至第一个active子节点。

预期结果 #

A
      / \
     AA AB
      |
     AAA

方法一：纯Cypher递归查询（无需APOC） #

如果你的Neo4j环境没有安装APOC插件，可以用纯Cypher的递归逻辑实现：

// 匹配起始节点，确保它是active的
MATCH (start:Node {title: "A"})
WHERE start.active = true

// 递归遍历符合规则的路径
CALL {
  WITH start
  // 匹配所有从起始节点出发的路径
  MATCH path = (start)-[:RELATED_WITH*]->(child:Node)
  // 条件1：路径上所有节点都必须是active=true
  WHERE all(node IN nodes(path) WHERE node.active = true)
    // 条件2：如果父节点是ordered=true，当前子节点必须是它的第一个active子节点
    AND NOT EXISTS {
      MATCH (parent)-[:RELATED_WITH {order: < childOrder}]->(sibling:Node)
      WHERE parent = nodes(path)[size(nodes(path))-2]
        AND sibling.active = true
        AND parent.ordered = true
        AND childOrder = (relationships(path)[size(relationships(path))-1]).order
    }
  RETURN path
  // 把起始节点本身也包含进来
  UNION ALL
  RETURN (start) AS path
}

// 展开路径中的节点和关系，去重后返回
UNWIND nodes(path) AS node
UNWIND relationships(path) AS rel
RETURN DISTINCT node, rel;

方法二：使用APOC路径扩展（更灵活） #

如果环境允许安装APOC插件，用apoc.path.expandConfig可以更直观地自定义遍历规则：

MATCH (start:Node {title: "A"})
CALL apoc.path.expandConfig(start, {
  relationshipFilter: "RELATED_WITH>", // 只遍历出方向的RELATED_WITH关系
  labelFilter: ">Node", // 只遍历Node标签的子节点
  filterStartNode: true, // 对起始节点也应用过滤规则
  // 自定义回调函数，控制哪些节点可以被包含
  callback: 'node, path -> {
    // 首先排除非active的节点
    if (!node.active) return false;
    // 获取父节点（路径的最后一个节点就是当前节点的父节点）
    const parent = path.length > 0 ? path.endNode() : null;
    // 如果父节点是ordered=true，只保留第一个active子节点
    if (parent && parent.ordered) {
      // 按order排序父节点的所有出边
      const sortedRels = [...parent.relationships.outgoing("RELATED_WITH")].sort((a,b) => a.order - b.order);
      // 找到第一个指向active节点的边
      const firstActiveRel = sortedRels.find(rel => rel.endNode().active);
      // 当前节点必须是这个第一个active子节点
      return firstActiveRel && firstActiveRel.endNode() === node;
    }
    // 其他情况直接通过
    return true;
  }'
}) YIELD path
// 展开结果并去重
UNWIND nodes(path) AS node
UNWIND relationships(path) AS rel
RETURN DISTINCT node, rel;

逻辑说明 #

• 节点过滤：全程只保留active=true的节点，直接排除像AC这类 inactive 的节点。
• ordered节点处理：当父节点标记为ordered=true时，会按关系的order字段排序它的所有子节点，只取第一个active的节点（比如AA的子节点中只保留AAA）。
• 路径完整性：确保遍历的路径上所有节点都符合规则，不会出现中途包含inactive节点的情况。

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