匹配与一组其他节点相关的所有节点-Neo4j

Question

我刚开始使用neo4j，希望对解决问题有帮助。

我有一组Questions，需要信息（Slots）来回答。

该图的规则（即每个Slots的{​​{1}} required）如下所示：

Graph diagram here

在我有一组广告位的情况下[Question，Slot A]我希望能够检查所有Slot B是否与Questions相关，例如[Slots，Question 1]。

然后，我希望能够检查所有Question 2 Questions的{​​{1}}中哪个可用，例如[required]

这有可能吗，如果可以的话，我应该怎么做？

Answer 1

是的，有可能。

一些数据装置：

CREATE (q1:Question {name: "Q1"})
CREATE (q2:Question {name: "Q2"})
CREATE (s1:Slot {name: "Slot A"})
CREATE (s2:Slot {name: "Slot B"})
CREATE (s3:Slot {name: "Slot C"})
CREATE (q1)-[:REQUIRES]->(s1)
CREATE (q1)-[:REQUIRES]->(s2)
CREATE (q2)-[:REQUIRES]->(s1)
CREATE (q2)-[:REQUIRES]->(s3)

查找与广告位列表有关的问题：

MATCH p=(q:Question)-[:REQUIRES]->(slot)
WHERE slot.name IN ["Slot A", "Slot B"]
RETURN p

然后，找到与广告位列表相关的问题，如果广告位列表包含问题的所有必需广告位，则返回布尔值：

MATCH p=(q:Question)-[:REQUIRES]->(slot)
WHERE slot.name IN ["Slot A", "Slot B"]
WITH q, collect(slot) AS slots
RETURN q, ALL(x IN [(q)-[:REQUIRES]->(s) | s] WHERE x IN slots)

╒═════════════╤═══════════════════════════════════════════════════════╕
│"q"          │"ALL(x IN [(q)-[:REQUIRES]->(s) | s] WHERE x IN slots)"│
╞═════════════╪═══════════════════════════════════════════════════════╡
│{"name":"Q1"}│true                                                   │
├─────────────┼───────────────────────────────────────────────────────┤
│{"name":"Q2"}│false                                                  │
└─────────────┴───────────────────────────────────────────────────────┘

关于ALL(x IN [(q)-[:REQUIRES]->(s) | s] WHERE x IN slots)这一部分的一些解释

ALL谓词将检查列表中每个值的条件是否为真，例如ALL (x IN [10,20,30] WHERE x > 5)

extract快捷语法，您传递一个列表，它返回提取值的列表，例如，语法为extract(x IN <LIST> | <key to extract>)：

extract(x IN [{name: "Chris", age: 38},{name: "John", age: 27}] | x.age)

// equivalent to the shortcut syntax for extract, with square brackets

[x IN [{name: "Chris", age: 38},{name: "John", age: 27}] | x.age]

将返回[38,27]

现在将其组合：

对于每个路径，请提取Slot节点

[(q)-[:REQUIRES]->(s) | s]

Returns 

[s1, s2]

在先前收集的插槽节点列表中，s1和s2中的每一个都是吗？

ALL(x IN [(q)-[:REQUIRES]->(s) | s] WHERE x IN slots)

Return true or false

---

仅在真时返回问题：

MATCH p=(q:Question)-[:REQUIRES]->(slot)
WHERE slot.name IN ["Slot A", "Slot B"]
WITH q, collect(slot) AS slots
WITH q WHERE ALL(x IN [(q)-[:REQUIRES]->(s) | s] WHERE x IN slots)
RETURN q