当我在 Neo4j Cypher 查询中传递多个 ID 时，如何获得多个列表作为输出？

Question

我当前的密码查询如下

MATCH (p:xyz)-[:children *]->(c:xyz)
WHERE p.Code=100
WITH COLLECT (c) + p AS all 
UNWIND all as p MATCH (p)-[:children]->(c) 
RETURN collect(DISTINCT c.Code) as Children_Nodes

这给了我一个输出

"Children_Nodes"                                                      │
╞══════════════════════════════════════════════════════════════════════╡
│[101,102,103,104,105]│

如果我传递两个不同的 id 就像

MATCH (p:xyz)-[:children *]->(c:xyz)
WHERE p.Code IN [100,200]
WITH COLLECT (c) + p AS all 
UNWIND all as p MATCH (p)-[:children]->(c) 
RETURN collect(DISTINCT c.Code) as Children_Nodes

这将返回类似

"Children_Nodes"                                                      │
╞══════════════════════════════════════════════════════════════════════╡
│[101,102,103,104,105,201,202,203,204,205]│

但我真正需要的是两个不同的单独列表，而不是像上面那样的一个整理列表

"Children_Nodes"                                                      │
╞══════════════════════════════════════════════════════════════════════╡
│[101,102,103,104,105] [201,202,203,204,205]│

Answer 1

那这个呢？

MATCH (p:xyz)-[:children *]->(c:xyz)
WHERE p.Code IN [100,200]
WITH p, COLLECT (DISTINCT c.Code) AS children
RETURN COLLECT(children) AS Children_Nodes

Answer 2

这应该为每个p.Code返回一行，以及其后代的代码列表：

MATCH (p:xyz)-[:children*]->(c:xyz)
WHERE p.Code IN [100, 200]
RETURN p.Code AS pCode, COLLECT(DISTINCT c.Code) AS descendantCodes

Answer 3

我已经找到了我的问题的答案。 如果有人需要，他们可以参考以下答案。 我调整了给定的查询。 如果他们对我的问题有更好的解决方案，请回复。

MATCH path = (p:xyz)-[:children *]->(c:xyz) WHERE p.Code IN [100, 200]
WITH 
COLLECT(path) as paths, COLLECT (c) + p AS all UNWIND all as p
MATCH (p)-[:children]->(c) CALL apoc.convert.toTree(paths,true, {nodes: {xyz: 
['Code','Name']}}) yield  value as hierarchy RETURN hierarchy,collect(distinct c.Code) 
as code_list

但是当我不使用

CALL apoc.convert.toTree(paths,true, {nodes: {xyz: 
['Code','Name']}}) yield  value as hierarchy

而只是

MATCH path = (p:xyz)-[:children *]->(c:xyz)WHERE p.Code IN 
[100,200] WITH COLLECT(path) as paths, COLLECT (c) + p AS all UNWIND all as p 
MATCH (p)-[:children]->(c) CALL apoc.convert.toTree(paths,true, {nodes: 
{xyz: ['Code','Name']}}) yield  value as hierarchy RETURN 
hierarchy,collect(distinct c.Code) as code_list

我再次得到的输出是一个整理过的列表，而不是一个隔离的列表。