假设id和type是属性，这是有效的：

MATCH (n0 {id: "A"})--(n1 {type:2})--(n2)
WHERE n2.id IN ["D", "E"]
WITH collect(DISTINCT [n0, n1]) AS r1, collect(DISTINCT [n1, n2]) AS r2
WITH 
    COLLECT {
        WITH r1
        UNWIND r1 AS r
        WITH r[0].id AS lhs, 'type' + r[1].type AS rhs, count(*) AS num
        RETURN {lhs: lhs, rhs: rhs, num: num }
    } AS first, 
    COLLECT {
        WITH r2
        UNWIND r2 AS r
        WITH 'type' + r[0].type AS lhs, r[1].id AS rhs, count(*) AS num
        RETURN {lhs: lhs, rhs: rhs, num: num }
    } AS second
UNWIND first + second AS cn
RETURN 
    cn.lhs + ' to ' + cn.rhs + ': ' + cn.num + 
    CASE 
      WHEN cn.num = 1 THEN ' connection' 
      ELSE ' connections' 
    END AS result

字符串
不太好...

这个查询可能就足够了（它在每个结果行中重复相同的A_to_type2计数）：

MATCH ({id: "A"})-[r1]-({type:2})-[r2]-(n2)
WHERE n2.id IN ["D", "E"]
WITH COUNT(DISTINCT r1) AS A_to_type2, COLLECT({n2Id: n2.id, r2: r2}) AS data
UNWIND data AS d
RETURN A_to_type2, d.n2Id AS n2Id, COUNT(DISTINCT d.r2) AS type2_to_n2Id

字符串
示例数据的输出：

╒══════════╤════╤═════════════╕
│A_to_type2│n2Id│type2_to_n2Id│
╞══════════╪════╪═════════════╡
│2         │"D" │2            │
├──────────┼────┼─────────────┤
│2         │"E" │1            │
└──────────┴────┴─────────────┘

型
或者，返回一个包含type2_to_n2Id计数集合的单行：

MATCH ({id: "A"})-[r1]-({type:2})-[r2]-(n2)
WHERE n2.id IN ["D", "E"]
WITH COUNT(DISTINCT r1) AS A_to_type2, COLLECT({n2Id: n2.id, r2: r2}) AS data
UNWIND data AS d
WITH A_to_type2, d.n2Id AS n2Id, COUNT(DISTINCT d.r2) AS cnt
RETURN A_to_type2, COLLECT({n2Id: n2Id, count: cnt}) AS type2_to_n2Id

型
样品结果：

╒══════════╤══════════════════════════════════════════════╕
│A_to_type2│type2_to_n2Id                                 │
╞══════════╪══════════════════════════════════════════════╡
│2         │[{count: 2, n2Id: "D"}, {count: 1, n2Id: "E"}]│
└──────────┴──────────────────────────────────────────────┘

型