如何用Cypher（Neo4j）递归创建SGF游戏树结构

问题背景 #

我需要在Neo4j中用Cypher复现SGF游戏树，树的结构定义如下（TypeScript）：

type GameTree = {
  id: number;
  data: { [key: string]: string[] };
  parentId: number | null;
  children: GameTree[];
};

根节点是单独创建的GameNode，用于存储元数据。但我写的创建查询无法正常工作：

UNWIND $moves AS move

MATCH (parent)

WHERE ((parent:GameNode) OR (parent:MoveNode))
  AND parent.game_id = $gameId
  AND parent.id = move.parentId

CREATE   (parent)
        -[:NEXT_MOVE]
       ->(:MoveNode{
           game_id: $gameId,
           id:      move.id
         })

问题出在执行UNWIND和MATCH时，只有根节点存在，后续的父节点还没被创建，导致MATCH无法匹配到对应的父节点，无法递归生成整个树。

我想知道：Cypher是否支持递归创建？有没有相关的递归关键字或APOC工具可用？另外我想到一个替代方案，先创建所有MoveNode，再和父节点关联，代码如下：

// 1. 创建所有MoveNode

UNWIND $moveNodes AS move

CREATE (:MoveNode{
         game_id: move.game_id,
         id:      move.id
       })

// 2. 关联至父节点

WITH move

MATCH (parent{
        game_id: move.game_id,
        id:      move.parentId
      }),
      (m:MoveNode{
        game_id: move.game_id,
        id:      move.id
      })

WHERE parent:GameNode
   OR parent:MoveNode
  
CREATE (parent)-[:NEXT_MOVE]->(m)

解决方案 #

一、优化你的"先创建再关联"方案 #

这个思路是可行的，不过原代码存在两个小问题：一是WITH move会导致每个move单独处理，但第一步CREATE后没有传递正确的上下文；二是用CREATE可能重复创建节点。优化后的代码如下：

1. 批量创建所有MoveNode

UNWIND $moveNodes AS move
MERGE (:MoveNode {
  game_id: move.game_id,
  id: move.id
})

用MERGE替代CREATE，可以避免重复创建相同id的节点，保证数据唯一性。

2. 批量关联父节点

UNWIND $moveNodes AS move
// 匹配父节点（GameNode或MoveNode）
MATCH (parent)
WHERE (parent:GameNode OR parent:MoveNode)
  AND parent.game_id = move.game_id
  AND parent.id = move.parentId
// 匹配当前MoveNode
MATCH (m:MoveNode {
  game_id: move.game_id,
  id: move.id
})
// 用MERGE避免重复创建关系
MERGE (parent)-[:NEXT_MOVE]->(m)

分开两个查询执行，确保所有节点都创建完成后再关联父节点，此时MATCH能找到所有已存在的父节点。

二、使用APOC实现递归创建（按层级顺序创建） #

如果需要严格按照树的层级从根到叶子递归创建（必须父节点存在才创建子节点），可以借助Neo4j的APOC扩展工具，常用的有两种方式：

1. 按顺序逐个创建（适合扁平数据）

如果你的$moves是扁平数组，可以先按父节点排序，再用apoc.periodic.iterate逐个处理，确保父节点先被创建：

CALL apoc.periodic.iterate(
  // 先排序：根节点的子节点优先，层级越深越靠后
  "UNWIND $moves AS move ORDER BY move.parentId IS NOT NULL, move.parentId RETURN move",
  // 匹配父节点并创建子节点
  "MATCH (parent) 
   WHERE (parent:GameNode OR parent:MoveNode) 
     AND parent.game_id = $gameId 
     AND parent.id = move.parentId 
   CREATE (parent)-[:NEXT_MOVE]->(:MoveNode {game_id: $gameId, id: move.id})",
  {batchSize: 1, params: {gameId: $gameId, moves: $moves}}
)

batchSize:1确保每次只处理一个节点，排序逻辑保证父节点在子节点之前被处理，这样MATCH总能找到已存在的父节点。

2. 递归遍历树形数据（适合嵌套数据）

如果你的输入数据是嵌套的树形结构（每个节点包含children字段），可以用apoc.recurse递归创建：

// 先匹配根节点
MATCH (root:GameNode {game_id: $gameId})
// 递归创建子节点
CALL apoc.recurse(root,
  // 递归遍历的关系（已创建的子节点）
  "MATCH (n)-[:NEXT_MOVE]->(child) RETURN child",
  // 递归执行的创建逻辑：为当前节点创建未存在的子节点
  "UNWIND [child IN $treeData WHERE child.parentId = n.id] AS newChild 
   CREATE (n)-[:NEXT_MOVE]->(:MoveNode {game_id: $gameId, id: newChild.id})",
  {params: {gameId: $gameId, treeData: $treeData}}
)
YIELD value
RETURN count(*) AS createdNodesCount

这里的$treeData是嵌套的GameTree数组，递归过程会从根节点开始，逐层创建所有子节点。

总结 #

• 先创建再关联是最直接、易维护的方案，适合大多数场景；
• APOC递归创建适合需要严格按层级顺序生成树的场景，尤其是数据本身是嵌套结构时；
• 无论哪种方案，都建议用MERGE替代CREATE，避免重复创建节点或关系，保证数据一致性。

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