Neo4J Cypher用于获取组合

我试图找到一种将组合组合组合在一起的方法。 假设我们有个人、爱好、地点、城市类型的节点。假设图形具有以下关系（合并）

在他计划每一项爱好做一次的一天里，有8个地方可以徒步旅行、吃喝。我希望能够在查询中捕获这一点

天真的做法

MATCH (p:Person)-[:likes]->(h:Hobby)-[:canDoAt]->(pl:Place)
RETURN p, h, pl

最多只能按个人和爱好分组，这将导致相同爱好的行被分组在一起。我想要的是以某种方式按组合分组，即：

//Joe Combo 1// Joe,hike,Mountain
                Joe,eat,Daves
                Joe,drink,Lounge
//Joe Combo 2// Joe,hike,Lake  
                Joe,eat,Daves
                Joe,drink,Lounge 

---

有没有一种方法可以为所有路径匹配指定一个数字，然后使用该分配进行排序？

我很确定你不能在cypher中这样做。你要找的是按个人和爱好分组的所有地方的笛卡尔积

A: [ [Joe, hike, Mountain], [Joe, hike, Lake] ]
B: [ [Joe, eat, Daves], [Joe, eat, Diner] ]
C: [ [Joe, drink, Lounge], [Joe, drink, Bar] ]

您正在寻找

A x B x C

据我所知，你不能像这样用密码分组返回。您应该返回所有person、hobby、place行，并在Python脚本中执行此操作，在该脚本中构建分组集并计算笛卡尔积

---

问题是，随着兴趣爱好和地点的增加，你会得到很多组合。

这是一个非常好的问题！我还没有完整的解决方案，但有一些想法：正如Martin Preusse所说，我们正在寻找一个笛卡尔乘积

这很困难，但您可以通过大量的黑客攻击来解决，包括使用双reduce：

WITH [['a', 'b'], [1, 2, 3], [true, false]] AS hs
WITH hs, size(hs) AS numberOfHobbys, reduce(acc = 1, h in hs | acc * size(h)) AS numberOfCombinations, extract(h IN hs | length(h)) AS hLengths
WITH hs, hLengths, numberOfHobbys, range(0, numberOfCombinations-1) AS combinationIndexes
UNWIND combinationIndexes AS combinationIndex
WITH
  combinationIndex,
  reduce(acc = [], i in range(0, numberOfHobbys-1) |
    acc + toInt(combinationIndex/(reduce(acc2 = 1, j in range(0, i-1) | acc2 * hLengths[j]))) % hLengths[i]
  ) AS indices,
  reduce(acc = [], i in range(0, numberOfHobbys-1) |  
    acc + reduce(acc2 = 1, j in range(0, i-1) | acc2 * hLengths[j])
  ) AS multipliers,
  reduce(acc = [], i in range(0, numberOfHobbys-1) |
    acc + hs[i][
      toInt(combinationIndex/(reduce(acc2 = 1, j in range(0, i-1) | acc2 * hLengths[j]))) % hLengths[i]
    ]
  ) AS combinations
RETURN combinationIndex, indices, multipliers, combinations

其思想如下：我们乘以潜在值的数量，例如，对于

['a'，'b'，[1,2,3]，[true，false]

，我们使用查询中的第一个

reduce

计算

n=2×3×2=12

。然后我们从0迭代到n-1，并使用公式

a×1+b×2+c×6

，其中a、b、c索引各自的值，因此都是非负整数

a<2

，

b<3

和

c<2

0×1 + 0×2 + 0×6 = 0
1×1 + 0×2 + 0×6 = 1
0×1 + 1×2 + 0×6 = 2
1×1 + 1×2 + 0×6 = 3
0×1 + 2×2 + 0×6 = 4
1×1 + 2×2 + 0×6 = 5
0×1 + 0×2 + 1×6 = 6
1×1 + 0×2 + 1×6 = 7
0×1 + 1×2 + 1×6 = 8
1×1 + 1×2 + 1×6 = 9
0×1 + 2×2 + 1×6 = 10
1×1 + 2×2 + 1×6 = 11

结果是：

╒════════════════╤═════════╤═══════════╤═════════════╕
│combinationIndex│indices  │multipliers│combinations │
╞════════════════╪═════════╪═══════════╪═════════════╡
│0               │[0, 0, 0]│[1, 2, 6]  │[a, 1, true] │
├────────────────┼─────────┼───────────┼─────────────┤
│1               │[1, 0, 0]│[1, 2, 6]  │[b, 1, true] │
├────────────────┼─────────┼───────────┼─────────────┤
│2               │[0, 1, 0]│[1, 2, 6]  │[a, 2, true] │
├────────────────┼─────────┼───────────┼─────────────┤
│3               │[1, 1, 0]│[1, 2, 6]  │[b, 2, true] │
├────────────────┼─────────┼───────────┼─────────────┤
│4               │[0, 2, 0]│[1, 2, 6]  │[a, 3, true] │
├────────────────┼─────────┼───────────┼─────────────┤
│5               │[1, 2, 0]│[1, 2, 6]  │[b, 3, true] │
├────────────────┼─────────┼───────────┼─────────────┤
│6               │[0, 0, 1]│[1, 2, 6]  │[a, 1, false]│
├────────────────┼─────────┼───────────┼─────────────┤
│7               │[1, 0, 1]│[1, 2, 6]  │[b, 1, false]│
├────────────────┼─────────┼───────────┼─────────────┤
│8               │[0, 1, 1]│[1, 2, 6]  │[a, 2, false]│
├────────────────┼─────────┼───────────┼─────────────┤
│9               │[1, 1, 1]│[1, 2, 6]  │[b, 2, false]│
├────────────────┼─────────┼───────────┼─────────────┤
│10              │[0, 2, 1]│[1, 2, 6]  │[a, 3, false]│
├────────────────┼─────────┼───────────┼─────────────┤
│11              │[1, 2, 1]│[1, 2, 6]  │[b, 3, false]│
└────────────────┴─────────┴───────────┴─────────────┘

因此，对于您的问题，查询可能如下所示：

MATCH (p:Person)-[:likes]->(h:Hobby)-[:canDoAt]->(pl:Place)
WITH p, h, collect(pl.name) AS places
WITH p, collect(places) AS hs
WITH hs, size(hs) AS numberOfHobbys, reduce(acc = 1, h in hs | acc * size(h)) AS numberOfCombinations, extract(h IN hs | length(h)) AS hLengths
WITH hs, hLengths, numberOfHobbys, range(0, numberOfCombinations-1) AS combinationIndexes
UNWIND combinationIndexes AS combinationIndex
WITH
  reduce(acc = [], i in range(0, numberOfHobbys-1) |
    acc + hs[i][
      toInt(combinationIndex/(reduce(acc2 = 1, j in range(0, i-1) | acc2 * hLengths[j]))) % hLengths[i]
    ]
  ) AS combinations
RETURN combinations

╒════════════════════════════════════╕
│combinations                        │
╞════════════════════════════════════╡
│[Diner, Lounge, Lake]               │
├────────────────────────────────────┤
│[Daves BarGrill, Lounge, Lake]      │
├────────────────────────────────────┤
│[Diner, Dive Bar, Lake]             │
├────────────────────────────────────┤
│[Daves BarGrill, Dive Bar, Lake]    │
├────────────────────────────────────┤
│[Diner, Lounge, Mountain]           │
├────────────────────────────────────┤
│[Daves BarGrill, Lounge, Mountain]  │
├────────────────────────────────────┤
│[Diner, Dive Bar, Mountain]         │
├────────────────────────────────────┤
│[Daves BarGrill, Dive Bar, Mountain]│
└────────────────────────────────────┘

这看起来像这样：

MATCH (p:Person)-[:likes]->(h:Hobby)-[:canDoAt]->(pl:Place)
WITH p, h, collect(pl.name) AS places
WITH p, collect(places) AS hs
WITH hs, size(hs) AS numberOfHobbys, reduce(acc = 1, h in hs | acc * size(h)) AS numberOfCombinations, extract(h IN hs | length(h)) AS hLengths
WITH hs, hLengths, numberOfHobbys, range(0, numberOfCombinations-1) AS combinationIndexes
UNWIND combinationIndexes AS combinationIndex
WITH
  reduce(acc = [], i in range(0, numberOfHobbys-1) |
    acc + hs[i][
      toInt(combinationIndex/(reduce(acc2 = 1, j in range(0, i-1) | acc2 * hLengths[j]))) % hLengths[i]
    ]
  ) AS combinations
RETURN combinations

╒════════════════════════════════════╕
│combinations                        │
╞════════════════════════════════════╡
│[Diner, Lounge, Lake]               │
├────────────────────────────────────┤
│[Daves BarGrill, Lounge, Lake]      │
├────────────────────────────────────┤
│[Diner, Dive Bar, Lake]             │
├────────────────────────────────────┤
│[Daves BarGrill, Dive Bar, Lake]    │
├────────────────────────────────────┤
│[Diner, Lounge, Mountain]           │
├────────────────────────────────────┤
│[Daves BarGrill, Lounge, Mountain]  │
├────────────────────────────────────┤
│[Diner, Dive Bar, Mountain]         │
├────────────────────────────────────┤
│[Daves BarGrill, Dive Bar, Mountain]│
└────────────────────────────────────┘

显然，我们还想了解此人及其爱好的名称：

MATCH (p:Person)-[:likes]->(h:Hobby)-[:canDoAt]->(pl:Place)
WITH p, h, collect([h.name, pl.name]) AS places
WITH p, collect(places) AS hs
WITH p, hs, size(hs) AS numberOfHobbys, reduce(acc = 1, h in hs | acc * size(h)) AS numberOfCombinations, extract(h IN hs | length(h)) AS hLengths
WITH p, hs, hLengths, numberOfHobbys, range(0, numberOfCombinations-1) AS combinationIndexes
UNWIND combinationIndexes AS combinationIndex
WITH
  p, reduce(acc = [], i in range(0, numberOfHobbys-1) |
    acc + [hs[i][
      toInt(combinationIndex/(reduce(acc2 = 1, j in range(0, i-1) | acc2 * hLengths[j]))) % hLengths[i]
    ]]
  ) AS combinations
RETURN p, combinations

结果是：

╒═══════════╤════════════════════════════════════════════════════════════╕
│p          │combinations                                                │
╞═══════════╪════════════════════════════════════════════════════════════╡
│{name: Joe}│[[eat, Diner], [drink, Lounge], [hike, Lake]]               │
├───────────┼────────────────────────────────────────────────────────────┤
│{name: Joe}│[[eat, Daves BarGrill], [drink, Lounge], [hike, Lake]]      │
├───────────┼────────────────────────────────────────────────────────────┤
│{name: Joe}│[[eat, Diner], [drink, Dive Bar], [hike, Lake]]             │
├───────────┼────────────────────────────────────────────────────────────┤
│{name: Joe}│[[eat, Daves BarGrill], [drink, Dive Bar], [hike, Lake]]    │
├───────────┼────────────────────────────────────────────────────────────┤
│{name: Joe}│[[eat, Diner], [drink, Lounge], [hike, Mountain]]           │
├───────────┼────────────────────────────────────────────────────────────┤
│{name: Joe}│[[eat, Daves BarGrill], [drink, Lounge], [hike, Mountain]]  │
├───────────┼────────────────────────────────────────────────────────────┤
│{name: Joe}│[[eat, Diner], [drink, Dive Bar], [hike, Mountain]]         │
├───────────┼────────────────────────────────────────────────────────────┤
│{name: Joe}│[[eat, Daves BarGrill], [drink, Dive Bar], [hike, Mountain]]│
└───────────┴────────────────────────────────────────────────────────────┘

我可能想得太多了，所以欢迎发表任何评论

---

重要的一点是：纯密码非常复杂，这可能是一个很好的迹象，表明您最好从客户端应用程序中计算出来。

接受经过深思熟虑的解决方案！。是的，写一个简单的查询，列出person、hobbie、list（place）和cilent应用程序中的其他内容可能更有意义。你想得太多了，但它仍然令人印象深刻；）