Neo4j 将两个Cypher语句的输出与聚合结合起来

我有以下单独的密码查询：

Q1: START m=node(30) MATCH (m)-[d:define]->(n) where d.start=4 RETURN n.name,COUNT(d) as count
Q2: START m=node(30) MATCH (m)-[d:define]->(n) where d.start=5 RETURN n.name,COUNT(d) as count

返回以下示例结果：

从第一季度开始：

a | 2
b | 1
c | 4
d | 3

从第二季度开始：

a | 1
b | 1
c | 4
e | 2

我可以脱机处理结果并生成一个合并计数，但是我可以合并上面的两个密码查询，以便从d.start 4和5获得以下合并计数吗

a | 2 | 1
b | 1 | 1
c | 4 | 4
d | 3 | 0
e | 0 | 2

到目前为止，我所拥有的是：我如何才能将姓名和计数（d）继续到下一阶段

START m=node(30) 
MATCH (m)-[d:define]->(n) 
where d.start=4
WITH m, COLLECT (n.name, COUNT(d)) as from1
MATCH (m)-[d:define]->(n) 
where d.start=5
WITH m, COLLECT (n.name, COUNT(d)) as from2

联盟对我不起作用，因为我不想把结果联合在一起。我需要将d.start=4和5的计数分开，这样更像是一个交叉点

MATCH (n)
WHERE ID(n) = 30
MATCH (m)-[d:define]->(n) 
where d.start=4
WITH m, COLLECT([n.name, COUNT(c)]) as from1
MATCH (m)-[d:define]->(n) 
where d.start=5
WITH m, from1 + COLLECT([n.name, COUNT(c)]) as from2
UNWIND from2 AS row
WITH row[0] AS name, row[1] AS ct
RETURN name, SUM(ct)

---

虽然我不能完全确定这是否会返回您期望的计数，因为您首先查找

n

，然后将

m

向前推进，这样

（m）-[d]>（n）

路径将匹配根本不同的模式。不过，你的思路是对的；只需不断向集合中添加内容，直到获得所有结果行，然后展开一个大集合并执行聚合或其他分析。

我相信您可以放弃

集合

，只使用

计数

示例数据集：

CREATE
  (m {name: 1}),
  (m)-[:define {start: 4}]->({name: 2}),
  (m)-[:define {start: 4}]->({name: 3}),
  (m)-[:define {start: 5}]->({name: 4})

查询：

MATCH (m)-[d:define]->()
WHERE d.start=4 
WITH m, COUNT(d) as from1
MATCH (m)-[d:define]->()
WHERE d.start=5
RETURN m.name, from1, COUNT(d) as from2

结果:

╒══════╤═════╤═════╕
│m.name│from1│from2│
╞══════╪═════╪═════╡
│1     │2    │1    │
└──────┴─────┴─────┘

---

此查询应执行您想要的操作：

MATCH (m)-[d:define]->(n)
WHERE ID(m) = 30 AND d.start IN [4, 5]
RETURN n.name AS name, REDUCE(c = [0, 0], x IN COLLECT(d.start) |
  CASE WHEN x = 4 THEN [c[0]+1, c[1]] ELSE [c[0], c[1]+1] END) AS counts
ORDER BY name;

您可以通过首先创建示例数据来测试它：

CREATE (m:Foo), (a:Foo {name: 'a'}), (b:Foo {name: 'b'}), (c:Foo {name: 'c'}), (d:Foo {name: 'd'}), (e:Foo {name: 'e'}),
  (m)-[:define {start:4}]->(a),
  (m)-[:define {start:4}]->(a),
  (m)-[:define {start:4}]->(b),
  (m)-[:define {start:4}]->(c),
  (m)-[:define {start:4}]->(c),
  (m)-[:define {start:4}]->(c),
  (m)-[:define {start:4}]->(c),
  (m)-[:define {start:4}]->(d),
  (m)-[:define {start:4}]->(d),
  (m)-[:define {start:4}]->(d),
  (m)-[:define {start:5}]->(a),
  (m)-[:define {start:5}]->(b),
  (m)-[:define {start:5}]->(c),
  (m)-[:define {start:5}]->(c),
  (m)-[:define {start:5}]->(c),
  (m)-[:define {start:5}]->(c),
  (m)-[:define {start:5}]->(e),
  (m)-[:define {start:5}]->(e);

使用上述数据（并假设查询对

m

使用正确的

ID

），查询返回：

+---------------+
| name | counts |
+---------------+
| "a"  | [2,1]  |
| "b"  | [1,1]  |
| "c"  | [4,4]  |
| "d"  | [3,0]  |
| "e"  | [0,2]  |
+---------------+

---

你的问题似乎有几个拼写错误。例如，Q1和Q2定义了

A

，但从不使用它。您的最终查询计数

c

，这在任何地方都没有定义。您能否至少纠正这些问题，并提供示例数据以给出您显示的结果？（此外，在最新版本的Cypher中，您不能再以使用它的方式使用

START

，但这相对容易修复）。您的解决方案已经不远了。您不必使用collect，只需在第一个

WITH

子句中使用

COUNT（d1）as from1

，并使用

RETURN m，from1，

而不是第二个

WITH

@cybersam抱歉，拼写错误已经修复。我使用的是一个旧版本的Cypher，因此开始了。我修复了底部查询中剩下的3个拼写错误。