Graph 获取Neo4J中特定类型的所有子图

我有一组节点和关系，我想得到一个节点的特定类型的子图。为了解释这个问题，附上了图表的图片

黄色节点由绿色节点通过关系“IS_PART_OF”连接。当我们查看上述片段时，黄色节点“8366854”由4个绿色节点“P10398”、“P10398-2”、“A0A024”和“P02647”连接，其中黄色节点“8366931”由2个绿色节点“A0A024”和“P02647”连接。所以绿色节点“A0A024”和“P02647”对这两个节点都是通用的，我可以说黄色节点“8366931”是“8366854”的子节点。只有当两个节点的所有绿色节点都是公共的时，才会发生这种情况

因此，我的查询将是一个黄色节点id，比如“8366854”，返回所有子黄色节点（在本例中仅为“8366931”）

这样对于下面的片段，我可以说

1） “8366523”是“8366848”的子项

---

2） “8366915”不是“8366848”的子节点，因为它没有所有的绿色节点。实际上，密码允许您通过一系列指令来表达这一点：

• 把黄色的节点拿走，把他所有的绿色邻居都拿走
• 让每个绿色邻居找到黄色和绿色邻居
• 确保对于第二个黄色邻居，每个绿色邻居也是第一个黄色节点的邻居

---

匹配（Y1:黄色）（Y2:黄色）尺寸（绿色2）和
全部（绿色2中的G，其中绿色1中的G）
返回Y1，收集（Y2）作为子项

1。创建图形： 第一条语句创建节点，第二条语句创建节点之间的关系

CREATE
  (Yellow1:Yellow {name: 'Yellow 1'}),
  (Yellow2:Yellow {name: 'Yellow 2'}),
  (Yellow3:Yellow {name: 'Yellow 3'}),
  (Yellow4:Yellow {name: 'Yellow 4'}),
  (Yellow5:Yellow {name: 'Yellow 5'}),
  (Yellow6:Yellow {name: 'Yellow 6'}),
  (Green1:Green {name: 'Green 1'}),
  (Green2:Green {name: 'Green 2'}),
  (Green3:Green {name: 'Green 3'}),
  (Green4:Green {name: 'Green 4'}),
  (Green5:Green {name: 'Green 5'}),
  (Green6:Green {name: 'Green 6'}),
  (Green7:Green {name: 'Green 7'}),
  (Green8:Green {name: 'Green 8'}),
  (Green9:Green {name: 'Green 9'}),
  (Green10:Green {name: 'Green 10'}),
  (Green11:Green {name: 'Green 11'}),
  (Green12:Green {name: 'Green 12'}),
  (Green13:Green {name: 'Green 13'})

CREATE
// upper graph
  (Green1)-[:IS_PART_OF]->(Yellow1),
  (Green2)-[:IS_PART_OF]->(Yellow1),
  (Green3)-[:IS_PART_OF]->(Yellow1),
  (Green4)-[:IS_PART_OF]->(Yellow1),
  (Green3)-[:IS_PART_OF]->(Yellow2),
  (Green4)-[:IS_PART_OF]->(Yellow2),
// lower graph
  (Green5)-[:IS_PART_OF]->(Yellow3),
  (Green6)-[:IS_PART_OF]->(Yellow3),
  (Green5)-[:IS_PART_OF]->(Yellow4),
  (Green6)-[:IS_PART_OF]->(Yellow4),
  (Green7)-[:IS_PART_OF]->(Yellow4),
  (Green8)-[:IS_PART_OF]->(Yellow4),
  (Green7)-[:IS_PART_OF]->(Yellow5),
  (Green8)-[:IS_PART_OF]->(Yellow5),
  (Green9)-[:IS_PART_OF]->(Yellow5),
  (Green10)-[:IS_PART_OF]->(Yellow5),
  (Green11)-[:IS_PART_OF]->(Yellow5),
  (Green12)-[:IS_PART_OF]->(Yellow5),
  (Green8)-[:IS_PART_OF]->(Yellow6),
  (Green13)-[:IS_PART_OF]->(Yellow6);

2.提议的解决办法： 2.1基本理念： 对于黄色节点“this”，将与其他黄色节点“that”的关系量与节点“this”的所有关系量进行比较。如果金额相等，则节点“this”是“that”的子节点

2.2说明：

识别两个黄色节点之间的所有对

识别黄色-黄色对中的所有绿色节点

计算黄色-黄色对中绿色节点的数量

识别被检查黄色节点的所有关系

统计正在检查的黄色节点的所有关系的数量

过滤那些黄色对，其中所有关系的数量等于对关系的数量

2.3塞弗声明：

---

…您已经尝试了什么？谢谢@weather@forknowledge为什么我们需要使用pairRelation和startNode，然后使用绿色节点的计数，而不是直接使用下面的，

code

MATCH yellowPairPath=（yellowA:Yellow）（yellowB:Yellow）与不同的yellowA、yellowB、与yellowA的pairRelation、作为绿色节点，yellowB和yellowA，计数（绿色节点）为pairRelationAmount，yellowB

code

@SreenathS，感谢您的额外查询！您建议的Cypher语句将查找两个黄色节点之间的所有路径，并对其包含的绿色节点进行计数。它不包括黄色节点之一可能的其他绿色节点。根据您的要求，如果黄色节点共享所有绿色节点，则黄色节点仅为其他黄色节点的子节点。由于您提议的声明中没有提供这种比较，不幸的是，您无法再识别任何SUB。因此，您需要

pairRelation

和

startNode

部分。我的Cypher语句背后的思想可以总结如下：对于黄色节点，“this”将关系的数量与另一个黄色节点“this”的所有关系的数量进行比较。如果金额相等，则节点“this”是“that”的子节点。

CREATE
  (Yellow1:Yellow {name: 'Yellow 1'}),
  (Yellow2:Yellow {name: 'Yellow 2'}),
  (Yellow3:Yellow {name: 'Yellow 3'}),
  (Yellow4:Yellow {name: 'Yellow 4'}),
  (Yellow5:Yellow {name: 'Yellow 5'}),
  (Yellow6:Yellow {name: 'Yellow 6'}),
  (Green1:Green {name: 'Green 1'}),
  (Green2:Green {name: 'Green 2'}),
  (Green3:Green {name: 'Green 3'}),
  (Green4:Green {name: 'Green 4'}),
  (Green5:Green {name: 'Green 5'}),
  (Green6:Green {name: 'Green 6'}),
  (Green7:Green {name: 'Green 7'}),
  (Green8:Green {name: 'Green 8'}),
  (Green9:Green {name: 'Green 9'}),
  (Green10:Green {name: 'Green 10'}),
  (Green11:Green {name: 'Green 11'}),
  (Green12:Green {name: 'Green 12'}),
  (Green13:Green {name: 'Green 13'})

CREATE
// upper graph
  (Green1)-[:IS_PART_OF]->(Yellow1),
  (Green2)-[:IS_PART_OF]->(Yellow1),
  (Green3)-[:IS_PART_OF]->(Yellow1),
  (Green4)-[:IS_PART_OF]->(Yellow1),
  (Green3)-[:IS_PART_OF]->(Yellow2),
  (Green4)-[:IS_PART_OF]->(Yellow2),
// lower graph
  (Green5)-[:IS_PART_OF]->(Yellow3),
  (Green6)-[:IS_PART_OF]->(Yellow3),
  (Green5)-[:IS_PART_OF]->(Yellow4),
  (Green6)-[:IS_PART_OF]->(Yellow4),
  (Green7)-[:IS_PART_OF]->(Yellow4),
  (Green8)-[:IS_PART_OF]->(Yellow4),
  (Green7)-[:IS_PART_OF]->(Yellow5),
  (Green8)-[:IS_PART_OF]->(Yellow5),
  (Green9)-[:IS_PART_OF]->(Yellow5),
  (Green10)-[:IS_PART_OF]->(Yellow5),
  (Green11)-[:IS_PART_OF]->(Yellow5),
  (Green12)-[:IS_PART_OF]->(Yellow5),
  (Green8)-[:IS_PART_OF]->(Yellow6),
  (Green13)-[:IS_PART_OF]->(Yellow6);

//                     |-------------------------------------- (1) ---------------------------------------|
MATCH yellowPairPath = (yellowA:Yellow)<-[pairRelation:IS_PART_OF]-(:Green)-[:IS_PART_OF]->(yellowB:Yellow)
WITH DISTINCT yellowA, yellowB, pairRelation
//            |-------- (2) --------|
WITH yellowA, startNode(pairRelation) AS pairRelations, yellowB
//            |------- (3) ------|
WITH yellowA, count(pairRelations) AS pairRelationAmount, yellowB
//    |---------------------- (4) -----------------------|
MATCH (yellowA:Yellow)<-[allRelations:IS_PART_OF]-(:Green)
//                                |------ (5) ------|
WITH yellowA, pairRelationAmount, count(allRelations) AS allRelationsAmount, yellowB
//      |---------------- (6) ----------------|
  WHERE pairRelationAmount = allRelationsAmount
RETURN yellowA, yellowB;

╒═══════════════════╤═══════════════════╕
│"yellowA"          │"yellowB"          │
╞═══════════════════╪═══════════════════╡
│{"name":"Yellow 2"}│{"name":"Yellow 1"}│
├───────────────────┼───────────────────┤
│{"name":"Yellow 3"}│{"name":"Yellow 4"}│
└───────────────────┴───────────────────┘