Neo4j 匹配密码中的多重关系

试图在标签的基础上找到类似的电影。但是我还需要给定电影和每个类似电影的所有标签（进行一些计算）。但令人惊讶的是，

collect（h.w）

给出了h.w的重复值（其中

w

是

h

的一个属性）

这是密码查询。请帮忙

MATCH (m:Movie{id:1})-[h1:Has]->(t:Tag)<-[h2:Has]-(sm:Movie),
(m)-[h:Has]->(t0:Tag), 
(sm)-[H:Has]->(t1:Tag) 
WHERE m <> sm 
RETURN distinct(sm), collect(h.w)

---

返回

h

n次的每个结果，其中
n
是h

的

结果数。有没有办法解决这个问题？
我复制了这个问题的数据模型来帮助回答这个问题


然后，我使用Neo4j的在线控制台设置了一个示例数据集：

从您的问题运行以下查询：

MATCH (m:Movie { title: "The Matrix" })-[h1:HAS_TAG]->(t:Tag),
      (t)<-[h2:HAS_TAG]-(sm:Movie),
      (m)-[h:HAS_TAG]->(t0:Tag),
      (sm)-[H:HAS_TAG]->(t1:Tag)
WHERE m <> sm
RETURN DISTINCT sm, collect(h.weight)

MATCH（m:Movie{title:“矩阵”}）-[h1:HAS_TAG]->（t:TAG），
（t） （t0：标签），
（sm）-[H:有标签]->（t1:标签）
我在哪里
返回不同的sm，收集（h.重量）

其结果是：

（1：电影{片名：“矩阵：重新加载”}）[0.31,0.12,0.31,0.12,0.31,0.01,0.31,0.01]

问题是返回的关系重复，这导致集合中的权重重复。解决方案是使用将关系限制为不同的记录，然后返回这些关系的权重集合

MATCH (m:Movie { title: "The Matrix" })-[h1:HAS_TAG]->(t:Tag),
      (t)<-[h2:HAS_TAG]-(sm:Movie),
      (m)-[h:HAS_TAG]->(t0:Tag),
      (sm)-[H:HAS_TAG]->(t1:Tag)
WHERE m <> sm
WITH DISTINCT sm, h
RETURN sm, collect(h.weight)

MATCH（m:Movie{title:“矩阵”}）-[h1:HAS_TAG]->（t:TAG），
（t） （t0：标签），
（sm）-[H:有标签]->（t1:标签）
我在哪里
具有明显的sm，h
返回sm，收集（h.重量）

（1：电影{title:“矩阵：重新加载”}）[0.31,0.12,0.01]
恐怕我还是不太明白你的意图，但是关于重复结果的一般问题，这正是断开模式的工作方式。CyfER必须考虑一些类似

(:A), (:B)

作为一种模式，而不是两种模式。这意味着任何令人满意的图结构都被认为是一个独特的匹配。假设你有一个由

CREATE (:A), (:B), (:B)

并查询上面的模式，您将得到两个结果，即

neo4j-sh (?)$ MATCH (a:A),(b:B) RETURN *;
==> +-------------------------------+
==> | a             | b             |
==> +-------------------------------+
==> | Node[15204]{} | Node[15207]{} |
==> | Node[15204]{} | Node[15208]{} |
==> +-------------------------------+
==> 2 rows
==> 53 ms

类似地，当匹配模式
（x）-[h]>（y），（a）-[h]>（b）
时，cypher考虑两个模式部分的每个组合构成一个完整模式的唯一匹配–因此
h
的结果由
h
的结果合成

这就是模式匹配的工作方式。为了实现你想要的，你可以首先考虑如果你真的需要查询一个断开的模式。如果这样做，或者如果连接的模式也生成冗余匹配，则聚合一个或多个模式部分。一个简单的例子可能是

CREATE (a:A), (b1:B), (b2:B)
    , (c1:C), (c2:C), (c3:C)
    , a-[:X]->b1, a-[:X]->b2
    , a-[:Y]->c1, a-[:Y]->c2, a-[:Y]->c3

询问

MATCH (b:B)<-[:X]-(a:A)-[:Y]->(c:C)              // with 1 (a), 2 (b) and 3 (c) you get 6 matched paths
RETURN a, collect (b) as bb, collect (c) as cc   // after aggregation by (a) there is one path

MATCH（b:b）（c:c）//使用1（a）、2（b）和3（c）可以得到6条匹配的路径
返回a，将（b）收集为bb，将（c）收集为cc//

有时，将聚合作为中间步骤是有意义的

MATCH (b)<-[:X]-(a:A)              // 2 paths
WITH a, collect(b) as bb           // 1 path
MATCH a-[:Y]->(c)                  // 3 paths
RETURN a, bb, collect(c) as cc     // 1 path

匹配（b）（c）//3条路径
将a、bb、collect（c）作为cc//1路径返回
是否
b
和
sb
应该是
m
和
sm
？你能再说一遍你想要什么吗？看起来您返回了相关的电影
sm
，但随后您从
m
收集标签并按
sm
对它们进行分组。。。那可能是你的问题。你有控制台样本吗？啊，是的，那是一个打字错误，对此我很抱歉。我已经更正了代码。我希望所有可能的关系都连接到电影
m
和
sm
，并且只希望标签上的关系是
m
和
sm
的公共关系。也就是说，我想要h、h、h1、h2。但不知何故，这些价值被重复，这影响了与它们相关的计算。谢谢，但找到建议对我来说不是问题。问题在于与之相关的计算。像MATCH（x）-[h]->（y）、（a）-[h]->（b）RETURN h这样的查询返回h的每个结果n次，其中n是h的结果数。有没有办法解决这个问题？您需要更多地解释您的数据模型。什么是h.w？h是电影和它的任何标签之间的关系。
（m）-[h:Has]>（t0:Tag）
，而在h.w中（w是h的一个属性），我想上面所解释的就足够了。你认为还需要什么？我知道w是h的一个属性，但它是什么？谢谢你的洞察力。
MATCH (b)<-[:X]-(a:A)              // 2 paths
WITH a, collect(b) as bb           // 1 path
MATCH a-[:Y]->(c)                  // 3 paths
RETURN a, bb, collect(c) as cc     // 1 path