Neo4j数据库中最常见的元组_Neo4j_Cypher_Combinatorics

Neo4j数据库中最常见的元组

neo4j

Neo4j数据库中最常见的元组,neo4j,cypher,combinatorics,Neo4j,Cypher,Combinatorics,我的数据库中的订单和产品节点通过包含关系连接： (:order)-[:contains]->(:product) 我想知道是否有可能找到以相同顺序出现的最常见的n元组产品恐怕这是不可能的，因为我有超过1500种产品，使得这些产品之间可能的组合数量非常高，即使是小n，例如1500^4≈ 5*10^12 我已经为n=3编写了以下测试查询： MATCH (o:order)-[r:contains]->(p:product) WITH count(r) as NrProds, o MA

我的数据库中的订单和产品节点通过包含关系连接：

(:order)-[:contains]->(:product)

我想知道是否有可能找到以相同顺序出现的最常见的n元组产品

恐怕这是不可能的，因为我有超过1500种产品，使得这些产品之间可能的组合数量非常高，即使是小n，例如1500^4≈ 5*10^12

我已经为n=3编写了以下测试查询：

MATCH (o:order)-[r:contains]->(p:product)
WITH count(r) as NrProds, o 
MATCH (o)-[r:contains]->(p:product)
WHERE NrProds > 3
WITH o
MATCH  (o)-[r1:contains]->(p1:product),(o)-[r2:contains]->(p2:product),(o)-[r3:contains]->(p3:product)
WITH o,p1,p2,p3,count(r1) as r1,count(r2) as r2,count(r3) as r3
WITH  o,p1,p2,p3,
CASE WHEN r1<r2 AND r1<r3 THEN r1
     WHEN r2<r1 AND r2<r3 THEN r2
     WHEN r3<r1 AND r3<r2 THEN r3
     END as result
WITH result,o,p1,p2,p3
RETURN count(result) as NrPurchs, o.Id,p1.name,p2.name,p3.name ORDER BY NrPurchs DESC

匹配（o:order）-[r:contains]->（p:product）
将计数（r）作为NrProds，o
匹配（o）-[r:包含]->（p:产品）
其中NrProds>3
与o
匹配（o）-（r1:包含]->（p1:产品），（o）-（r2:包含]->（p2:产品），（o）-（r3:包含]->（p3:产品）
用o，p1，p2，p3，计数（r1）为r1，计数（r2）为r2，计数（r3）为r3
用o，p1，p2，p3，
案例r1正如您所指出的，产品的组合数量太多，因此最好从订单端开始生成元组，以仅生成现有元组
在筛选之前，您有一个不必要的匹配项
，以下内容应足以筛选出订单：
MATCH (o:order)-[r:contains]->(p:product)
WITH count(r) as NrProds, o 
WHERE NrProds >= 3 // note >= sign for orders with 3 and more
WITH o
...

或者如果您的订单
仅对产品使用包含
关系：
MATCH (o:order)
WITH o,size((o)-[:contains]->()) as NrProds
WHERE NrProds >= 3
WITH o
...

为了避免重复，通过按id、名称等对相同产品的排列进行排序，过滤掉它们。。（where子句仅适用于唯一的名称/ID。如果有重复项，则需要（））作为NrProds
其中NrProds>=3
与o
匹配
（o） -[r1:包含]->（p1:产品），
（o） -[r2:包含]->（p2:产品），
（o） -[r3:包含]->（p3:产品）
其中p1.name

正如您所指出的，产品的组合数量太多，因此最好从订单端开始生成元组，以仅生成现有元组

在筛选之前，您有一个不必要的

匹配项

，以下内容应足以筛选出订单：

MATCH (o:order)-[r:contains]->(p:product)
WITH count(r) as NrProds, o 
WHERE NrProds >= 3 // note >= sign for orders with 3 and more
WITH o
...

或者如果您的

订单

仅对产品使用

包含

关系：

MATCH (o:order)
WITH o,size((o)-[:contains]->()) as NrProds
WHERE NrProds >= 3
WITH o
...

为了避免重复，通过按id、名称等对相同产品的排列进行排序，过滤掉它们。。（where子句仅适用于唯一的名称/ID。如果有重复项，则需要（））作为NrProds 其中NrProds>=3 与o 匹配（o） -[r1:包含]->（p1:产品），（o） -[r2:包含]->（p2:产品），（o） -[r3:包含]->（p3:产品）其中p1.name这个查询肯定比我的要简洁得多。如果我等的时间足够长，我的电脑甚至可以完成。所以谢谢你。您是否添加了“WHERE p1.name其中< /代码>条件是避免重复的。我猜你认为P1，P2，P3和P3，P2，P1，…一模一样。使用一个订单和产品a、b、c进行尝试，然后查看第二个

匹配项返回的内容（后面没有聚合），以及仅使用一半条件时返回的内容等。。理解cypher如何绑定变量很重要。这个查询肯定比我的要简洁得多。如果我等的时间足够长，我的电脑甚至可以完成。所以谢谢你。您是否添加了“WHERE p1.name其中< /代码>条件是避免重复的。我猜你认为P1，P2，P3和P3，P2，P1，…一模一样。使用一个订单和产品a、b、c进行尝试，然后查看第二个匹配项返回的内容（后面没有聚合），以及仅使用一半条件时返回的内容等。。理解cypher如何绑定变量很重要。
ORDER BY c DESC LIMIT {n}

MATCH (o:order)
WITH o,size((o)-[:contains]->()) as NrProds
WHERE NrProds >= 3
WITH o
MATCH 
  (o)-[r1:contains]->(p1:product),
  (o)-[r2:contains]->(p2:product),
  (o)-[r3:contains]->(p3:product)
WHERE p1.name < p2.name AND p2.name < p3.name
RETURN p1,p2,p3,COUNT(o) as c
ORDER BY c DESC LIMIT {n}