Javascript 按每个节点进行限制，而不是按整个查询进行限制

我有大量的用户和照片，它们之间有三种可能的关系（以后可能会添加更多）。这些关系由发布，

出现在

中，

在

中提到。给定一个特定的用户，我需要一个查询，该查询返回他们的网络到

n

跳转。例如，这应该包括他们发布的照片、他们出现或提到的照片，以及发布这些照片的帐户

我现在的问题是：

MATCH (root:account { username: {username} })-[r*1..4]-(u)
RETURN *
LIMIT 50

这样做的问题是限制是基于总行数完成的。这将导致在具有许多子节点时仅返回一个级别1节点。下面是对这个问题的更直观的解释

这是普通用户的外观（简化）：

如果找到的第一个节点有很多照片，则返回以下内容：

由于用户拥有大量媒体，因此在没有显示其网络的准确表示的情况下达到了极限。相反，我希望我的查询将每个节点的最大值限制为

n

子节点

---

从我在这里读到的几个答案来看，似乎可以使用

COLLECT

，但是我找不到任何示例。

您可以通过限制路径长度来使用cypher：

MATCH path=(root:account { username: {username} })-[r*1..4]-(u)
WITH COLLECT(path) as paths
RETURN filter(x in paths WHERE length(x)<50)

---

您可以通过限制路径长度来使用cypher执行此操作：

MATCH path=(root:account { username: {username} })-[r*1..4]-(u)
WITH COLLECT(path) as paths
RETURN filter(x in paths WHERE length(x)<50)

---

我认为您需要以下内容：

 MATCH (root:account { username: {username} })-[]-> (child1)-[r*1..4]-(u)
 RETURN child1, collect(u)
 LIMIT 50

这将返回多达50行

---

每行将有两列。第一列是child1s，第二列是这个孩子的“我们”

我想你需要如下内容：

 MATCH (root:account { username: {username} })-[]-> (child1)-[r*1..4]-(u)
 RETURN child1, collect(u)
 LIMIT 50

这将返回多达50行

---

每行将有两列。第一列为child1，第二列为该子项的“Us”

您可以手动构造此查询：

MATCH (root:account { username: {username} }) 
WITH {ids: [root], rels: []} as graph

UNWIND graph.ids as N  
  MATCH (N)-[r]->(C) WHERE NOT C IN graph.ids
  WITH graph, C, r LIMIT 50
  WITH graph, collect(C) as ids, collect(r) as rels
  WITH {ids: ids + graph.ids, rels: graph.rels + rels} as graph

UNWIND graph.ids as N  
  MATCH (N)-[r]->(C) WHERE NOT C IN graph.ids
  WITH graph, C, r LIMIT 50
  WITH graph, collect(C) as ids, collect(r) as rels
  WITH {ids: ids + graph.ids, rels: graph.rels + rels} as graph

UNWIND graph.ids as N  
  MATCH (N)-[r]->(C) WHERE NOT C IN graph.ids
  WITH graph, C, r LIMIT 50
  WITH graph, collect(C) as ids, collect(r) as rels
  WITH {ids: ids + graph.ids, rels: graph.rels + rels} as graph

UNWIND graph.ids as N  
  MATCH (N)-[r]->(C) WHERE NOT C IN graph.ids
  WITH graph, C, r LIMIT 50
  WITH graph, collect(C) as ids, collect(r) as rels
  WITH {ids: ids + graph.ids, rels: graph.rels + rels} as graph

RETURN graph.rels

---

当然，在发生大跳转时，可以通过javascript使用简单的连接来收集此结构。

您可以手动构造此查询：

MATCH (root:account { username: {username} }) 
WITH {ids: [root], rels: []} as graph

UNWIND graph.ids as N  
  MATCH (N)-[r]->(C) WHERE NOT C IN graph.ids
  WITH graph, C, r LIMIT 50
  WITH graph, collect(C) as ids, collect(r) as rels
  WITH {ids: ids + graph.ids, rels: graph.rels + rels} as graph

UNWIND graph.ids as N  
  MATCH (N)-[r]->(C) WHERE NOT C IN graph.ids
  WITH graph, C, r LIMIT 50
  WITH graph, collect(C) as ids, collect(r) as rels
  WITH {ids: ids + graph.ids, rels: graph.rels + rels} as graph

UNWIND graph.ids as N  
  MATCH (N)-[r]->(C) WHERE NOT C IN graph.ids
  WITH graph, C, r LIMIT 50
  WITH graph, collect(C) as ids, collect(r) as rels
  WITH {ids: ids + graph.ids, rels: graph.rels + rels} as graph

UNWIND graph.ids as N  
  MATCH (N)-[r]->(C) WHERE NOT C IN graph.ids
  WITH graph, C, r LIMIT 50
  WITH graph, collect(C) as ids, collect(r) as rels
  WITH {ids: ids + graph.ids, rels: graph.rels + rels} as graph

RETURN graph.rels

---

当然，在发生大跳转时，可以通过javascript使用简单的连接来收集此结构。

这是一个递归问题，目前在cypher中不存在此问题。我认为，如果目标是提高效率（速度和资源），那么单用一个cypher查询就无法解决这个问题。当然，必须有一种方法来限制每次“跳转”而不是整个查询返回的节点数？这是一个递归问题，目前cypher中没有这种问题。我认为，如果目标是提高效率（速度和资源），那么单用一个密码查询就无法解决这个问题。当然，必须有一种方法来限制每次“跳转”而不是整个查询返回的节点数？恐怕这并不能解决问题。这只是过滤到长度小于

50

的路径，这不是我的问题。我需要限制每个节点可以拥有的子节点的数量。您的查询需要扫描整个数据库，这将非常缓慢。恐怕这无法解决问题。这只是过滤到长度小于

50

的路径，这不是我的问题。我需要限制每个节点可以拥有的子节点的数量。您的查询需要扫描整个数据库，这将非常缓慢。