如何在GraphQL/REST系统中动态处理嵌套记录的增删改？

一、REST API标准化方案 #

1. 增量式Payload（带操作标记） #

沿用你提到的ID/新增/删除标记思路，给每个嵌套节点统一加操作标识，适配复杂层级：

• 带id的节点：执行更新逻辑
• 无id的节点：执行新增逻辑
• 带_delete: true的节点：执行删除逻辑

举个term结构的示例Payload：

{
  "id": "parent-term-1",
  "name": "Updated Parent Term",
  "children": [
    {"id": "child-term-1", "name": "Updated Child"}, // 更新已有子节点
    {"name": "New Child Node"}, // 新增子节点
    {"id": "child-term-2", "_delete": true} // 标记删除子节点
  ]
}

后端处理时递归遍历所有嵌套节点，按标记执行对应操作，注意配合PostgreSQL的外键ON DELETE CASCADE处理级联删除，或者在业务层校验子节点依赖关系。

2. 批量操作端点+指令式Payload #

设计专门的批量端点（比如POST /terms/batch），用指令数组明确操作类型和目标路径，类似JSON Patch但适配嵌套场景：

[
  {"op": "update", "path": "/terms/parent-term-1/name", "value": "New Parent Name"},
  {"op": "create", "path": "/terms/parent-term-1/children", "value": {"name": "New Child"}},
  {"op": "delete", "path": "/terms/parent-term-1/children/child-term-2"}
]

后端通过JSON Pointer规范解析路径，定位到嵌套节点执行操作。优点是传输数据量小，粒度可控；缺点是需要严格校验路径合法性，处理复杂嵌套时要注意解析逻辑的健壮性。

二、GraphQL方案（天生适配嵌套操作） #

1. 嵌套突变（Nested Mutations） #

利用GraphQL的类型系统，在父节点的突变中直接嵌套子节点的增删改操作，主流框架（Prisma、Hasura）原生支持：

mutation BatchUpdateTerm {
  updateTerm(id: "parent-term-1", name: "Updated Parent") {
    id
    children {
      create(data: {name: "New Child"}) { id }
      update(where: {id: "child-term-1"}, data: {name: "Updated Child"}) { id }
      delete(where: {id: "child-term-2"}) { id }
    }
  }
}

框架会自动将嵌套操作打包到一个事务中执行，处理关联关系和约束。

2. 批量指令式突变 #

如果需要更灵活的批量操作，定义接受数组参数的Mutation：

mutation BatchTermOperations($operations: [TermOperationInput!]!) {
  batchTermOperations(operations: $operations) {
    success
    message
  }
}

input TermOperationInput {
  op: OperationType! # 枚举：UPDATE/CREATE/DELETE
  termId: String
  data: TermDataInput
  childrenOperations: [ChildTermOperationInput!]
}

后端解析数组中的每个操作，递归处理嵌套的子节点操作，统一在一个PostgreSQL事务中完成。

三、PostgreSQL高效写入技巧 #

1. 事务包裹所有操作 #

不管用REST还是GraphQL，把嵌套增删改全放在一个事务里，避免部分成功部分失败：

BEGIN;
-- 更新父节点
UPDATE terms SET name = 'Updated Parent' WHERE id = 'parent-term-1';
-- 新增子节点
INSERT INTO term_children (term_id, name) VALUES ('parent-term-1', 'New Child');
-- 更新子节点
UPDATE term_children SET name = 'Updated Child' WHERE id = 'child-term-1';
-- 删除子节点
DELETE FROM term_children WHERE id = 'child-term-2';
COMMIT;

2. 批量SQL语句减少交互 #

用INSERT ... ON CONFLICT实现批量新增/更新，配合UNNEST处理数组参数：

-- 批量更新子节点
UPDATE term_children tc
SET name = upd.name
FROM UNNEST(
  ARRAY[
    ('child-term-1', 'Updated Child'),
    ('child-term-3', 'Another Updated Child')
  ]::term_update_input[]
) upd(id, name)
WHERE tc.id = upd.id;

可以提前在PostgreSQL中定义自定义类型term_update_input，直接接收API传来的数组参数，减少多次SQL调用。

3. JSONB类型适配灵活嵌套结构 #

如果嵌套结构多变，不需要严格关系型约束，用JSONB存储半结构化数据，直接批量更新字段：

-- 更新父节点名称+新增子节点
UPDATE terms
SET data = jsonb_set(
  data,
  '{name}',
  '"Updated Parent"'::jsonb,
  true
) || jsonb_set(
  data,
  '{children}',
  data->'children' || '{"name": "New Child"}'::jsonb,
  true
)
WHERE id = 'parent-term-1';

-- 删除指定子节点
UPDATE terms
SET data = jsonb_set(
  data,
  '{children}',
  (data->'children') - (SELECT index FROM jsonb_array_elements(data->'children') WITH ORDINALITY arr(elem, index) WHERE elem->>'id' = 'child-term-2'),
  true
)
WHERE id = 'parent-term-1';

注意这种方式查询性能不如关系型表，适合结构变化频繁的场景。

4. 避免N+1查询 #

处理嵌套数据时，用LATERAL查询一次性获取所有关联数据：

SELECT t.id, t.name, json_agg(tc.*) AS children
FROM terms t
LEFT JOIN LATERAL (
  SELECT * FROM term_children WHERE term_id = t.id
) tc ON true
WHERE t.id = 'parent-term-1'
GROUP BY t.id;

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