Neo4J（Cypher）按节点对多个关系进行分组

我正在开发一个小型的推荐系统，为下一场比赛推荐玩家。该推荐首先由以下玩家组成，然后由该玩家之前玩过的玩家按游戏数量排序

结果将是

Player，后面跟着（true | false），gameid

我有

Player

和

Game

节点，它们与

Game-[：HAS_Player]->Player

及

Player

节点直接关联为

Player-[：followers]>Player

我的测试数据库：

CREATE (superman:Player {playerID: 'superman', name:'Superman', sanitizedName: 'superman'})
CREATE (batman:Player {playerID: 'batman', name:'Batman', sanitizedName: 'batman'})
CREATE (catwoman:Player {playerID: 'catwoman', name:'Catwoman', sanitizedName: 'catwoman'})
CREATE (lois:Player {playerID: 'lois', name:'Lois Lane', sanitizedName: 'lois lane'})
CREATE (wonderwoman:Player {playerID: 'wonderwoman', name:'Wonder Woman', sanitizedName: 'wonder woman'})
CREATE (aquaman:Player {playerID: 'aquaman', name:'Aquaman', sanitizedName: 'aquaman'})
CREATE (flash:Player {playerID: 'flash', name:'Flash', sanitizedName: 'flash'})
CREATE (cyborg:Player {playerID: 'cyborg', name:'Cyborg', sanitizedName: 'cyborg'})
CREATE (joker:Player {playerID: 'joker', name:'Joker', sanitizedName: 'joker'})
CREATE (lex:Player {playerID: 'lex', name:'Lex Luthor', sanitizedName: 'lex luthor'})
CREATE (green:Player {playerID: 'green', name:'Green Lantern', sanitizedName: 'green lantern'})

CREATE (g1:Game {gameId:"game-1"})
CREATE (g1)-[:HAS_PLAYERS {teamId:"0"}]->(superman)
CREATE (g1)-[:HAS_PLAYERS {teamId:"0"}]->(aquaman)
CREATE (g1)-[:HAS_PLAYERS {teamId:"1"}]->(batman)
CREATE (g1)-[:HAS_PLAYERS {teamId:"1"}]->(flash)

CREATE (g2:Game {gameId:"game-2"})
CREATE (g2)-[:HAS_PLAYERS {teamId:"0"}]->(superman)
CREATE (g2)-[:HAS_PLAYERS {teamId:"0"}]->(batman)
CREATE (g2)-[:HAS_PLAYERS {teamId:"1"}]->(joker)
CREATE (g2)-[:HAS_PLAYERS {teamId:"1"}]->(lex)

CREATE (g3:Game {gameId:"game-3"})
CREATE (g3)-[:HAS_PLAYERS {teamId:"0"}]->(flash)
CREATE (g3)-[:HAS_PLAYERS {teamId:"0"}]->(lois)
CREATE (g3)-[:HAS_PLAYERS {teamId:"1"}]->(wonderwoman)
CREATE (g3)-[:HAS_PLAYERS {teamId:"1"}]->(aquaman)

CREATE (g4:Game {gameId:"game-4"})
CREATE (g4)-[:HAS_PLAYERS {teamId:"0"}]->(joker)
CREATE (g4)-[:HAS_PLAYERS {teamId:"0"}]->(cyborg)
CREATE (g4)-[:HAS_PLAYERS {teamId:"1"}]->(wonderwoman)
CREATE (g4)-[:HAS_PLAYERS {teamId:"1"}]->(green)

CREATE (g5:Game {gameId:"game-5"})
CREATE (g5)-[:HAS_PLAYERS {teamId:"0"}]->(catwoman)
CREATE (g5)-[:HAS_PLAYERS {teamId:"1"}]->(green)

CREATE (batman)-[:FOLLOWS]->(superman)
CREATE (batman)-[:FOLLOWS]->(catwoman)

CREATE (lex)-[:FOLLOWS]->(joker)
CREATE (joker)-[:FOLLOWS]->(lex)
;

根据这些数据，我想向蝙蝠侠推荐一名球员参加下一场比赛，结果必须是：

superman true  [game-1, game-2]
catwoman true  []
aquaman  false [game-1]
flash    false [game-1]
joker    false [game-2]
lex      false [game-2]

更新： 我有下一个问题，但缺少以下玩家：

MATCH (u:Player{playerID:"batman"})
OPTIONAL MATCH (u)<-[:HAS_PLAYERS]-(g:Game)-[:HAS_PLAYERS]->(p:Player) 
RETURN p, EXISTS((u)-[:FOLLOWS]->(p)) AS is_followed, COUNT(g) AS num_games, collect(g) AS games
ORDER BY num_games DESC

MATCH（u:Player{playerID:“蝙蝠侠”}）
可选比赛（u）（p:球员）
返回p，存在（（u）-[：FOLLOWS]->（p））按所跟随的顺序，将（g）计数为num\u游戏，将（g）收集为游戏
按数字排序游戏说明

谢谢大家!

更新2

这种方法可能更具“可读性”，但性能比公认的答案差得多

MATCH (u:Player{playerID:"batman"})
CALL {
    WITH u
    MATCH (u)<-[:HAS_PLAYERS]-(g:Game)-[:HAS_PLAYERS]->(p:Player) 
    RETURN p

    UNION

    WITH u
    MATCH (u)-[:FOLLOWS]->(p:Player)
    RETURN p
}
WITH p,
    EXISTS((u)-[:FOLLOWS]->(p)) AS is_followed,
    [(u)<-[:HAS_PLAYERS]-(g:Game)-[:HAS_PLAYERS]->(p) | g.gameId] AS games
RETURN p.name, is_followed, size(games) AS num_games, games
ORDER BY num_games DESC

MATCH（u:Player{playerID:“蝙蝠侠”}）
召唤{
和你
比赛（u）（p:球员）
返回p
联合
和你
匹配（u）-[：跟随]->（p:玩家）
返回p
}
有了p，
存在（（u）-[：following]->（p））如下所示，
[（u）（p）| g.gameId]作为游戏
返回p.name，后面是，大小（游戏）为num\u游戏，游戏
按数字排序游戏说明

你不能得到猫女，因为你只能通过：游戏节点匹配与蝙蝠侠相关的：玩家，你还需要匹配（u:Player{playerID:“蝙蝠侠”}）-[：FOLLOWS]>（p:Player）

MATCH（u:Player{playerID:“蝙蝠侠”}）
可选比赛（u）（p:球员）
返回p.playerID，存在（（u）-[：FOLLOWS]->（p））按所跟随的顺序，将（g）计数为num\u游戏，将（g.gameId）收集为游戏
按数字排序游戏说明
联盟
比赛（u:球员{playerID:“蝙蝠侠”}）-[：跟随]->（p:球员）
不存在时（（u）（p:玩家））
返回p.playerID，按原样为真，0作为num\u游戏，[]作为游戏

---

（想不出一个没有工会的办法，但这是可能的）

非常感谢。我继续努力，我的方法也有一个联盟，但你的表现更好。

MATCH (u:Player{playerID:"batman"})
OPTIONAL MATCH (u)<-[:HAS_PLAYERS]-(g:Game)-[:HAS_PLAYERS]->(p:Player) 
RETURN p.playerID, EXISTS((u)-[:FOLLOWS]->(p)) AS is_followed, COUNT(g) AS num_games, collect(g.gameId) AS games
ORDER BY num_games DESC
union
match (u:Player{playerID:"batman"})-[:FOLLOWS]->(p:Player)
where not exists( (u)<-[:HAS_PLAYERS]-(:Game)-[:HAS_PLAYERS]->(p:Player) )
RETURN p.playerID, true AS is_followed, 0 AS num_games, [] AS games