Scala Slick joinLeft 和组合条件

Question

我希望能够使用 Slick 创建一个查询，让我以动态方式过滤左连接

case class Player(
  id: Long,
  createdAt: DateTime,
  lastModificationDate: DateTime,
  name: String
)

class PlayerTable(tag: Tag)  extends Table[Player](tag, "players") {
  def id = column[Long]("id", O.PrimaryKey, O.AutoInc)
  def createdAt = column[DateTime]("createdAt")
  def lastModificationDate = column[DateTime]("lastModificationDate")
  def name = column[String]("name")
  override def * : ProvenShape[Player] = (
  id,
  createdAt,
  lastModificationDate,
  updatedAt,
  name
  ) <> (Player.tupled, Player.unapply)
}

case class PlayerGame(
  id: Long,
  createdAt: DateTime,
  lastModificationDate: DateTime,
  playerId: Long,
  level: Int,
  status: String
)

class PlayerGameTable(tag: Tag)  extends Table[PlayerGame](tag, "player_games") {
  def id = column[Long]("id", O.PrimaryKey, O.AutoInc)
  def createdAt = column[DateTime]("createdAt")
  def lastModificationDate = column[DateTime]("lastModificationDate")
  def playerId = column[Long]("playerId")
  def level = column[Int]("level")
  def status = column[String]("status")
  override def * : ProvenShape[PlayerGame] = (
  id,
  createdAt,
  lastModificationDate,
  playerId,
  level,
  status
  ) <> (PlayerGame.tupled, PlayerGame.unapply)
}

我想用 Slick 编写这样的查询，其中 WHERE CLAUSE 是动态的。我写了两个例子

SELECT *
FROM players
LEFT JOIN player_games AS playerGamesOne ON players.id = playerGamesOne.playerId AND playerGamesOne.level = 1
LEFT JOIN player_games AS playerGamesTwo ON players.id = playerGamesTwo.playerId AND playerGamesTwo.level = 2
WHERE playerGamesOne.status LIKE 'gameOver'
OR playerGamesTWO.status LIKE 'gameOver'


SELECT *
FROM players
LEFT JOIN player_games AS playerGamesOne ON players.id = playerGamesOne.playerId AND playerGamesOne.level = 1
LEFT JOIN player_games AS playerGamesTwo ON players.id = playerGamesTwo.playerId AND playerGamesTwo.level = 2
WHERE playerGamesOne.status LIKE 'playing'
OR playerGamesTwo.status NOT LIKE 'gameOver'

我正在尝试类似的操作，但我得到了 Rep[Option[PlayerGameTable]] 作为参数。也许有一种不同的方式来做这样的事情

val baseQuery = for {
  ((p, g1), g2) <- PlayerTable.playerQuery joinLeft 
    PlayerGameTable.playerGameQuery ON ((x, y) => x.id === y.playerId && y.level === 1) joinLeft
    PlayerGameTable.playerGameQuery ON ((x, y) => x._1.id === y.playerId && y.level === 2)
} yield (p, g1, g2)

private def filterPlayerGames(gameStatus: String, playerGamesOneOpt: Option[PlayerGameTable], playerGamesTwoOpt: Option[PlayerGameTable]) = {
  (gameStatus, playerGamesOneOpt, playerGamesOneOpt) match {
    case (gameStatus: String, Some(playerGamesOne: PlayerGameTable), Some(playerGamesOne: PlayerGameTable)) if gameStatus == "gameOver"  => playerGamesOne.status === "gameOver" || playerGamesTwo.status === "gameOver"
 }
}

这是一个复杂的问题，如果有什么不清楚的地方请告诉我，我会尽力澄清

Answer 1

有几个问题：

在多个条件下，ON 子句中使用的 underscore 占位符将无法按预期方式工作
_.level = something是赋值，不是条件

假设 PlayerTable.playerQuery 是 TableQuery[PlayerTable] 并且 PlayerGameTable.playerGameQuery 是 TableQuery[PlayerGameTable]，您的 baseQuery 应该是这样的：

val baseQuery = for {
  ((p, g1), g2) <- PlayerTable.playerQuery joinLeft 
    PlayerGameTable.playerGameQuery on ((x, y) => x.id === y.playerId && y.level === 1) joinLeft
    PlayerGameTable.playerGameQuery on ((x, y) => x._1.id === y.playerId && y.level === 2)
} yield (p, g1, g2)

我不完全清楚您的 filterPlayerGames 方法将如何处理动态条件。我也不认为任何过滤包装器方法都足够灵活以涵盖具有任意 and/or/negation 运算符的多个条件。我建议您将 baseQuery 用于必要的 join 并在其上构建过滤查询，类似于以下内容：

val query1 = baseQuery.filter{ case (_, g1, g2) =>
  g1.filter(_.status === "gameOver").isDefined || g2.filter(_.status === "gameOver").isDefined
}

val query2 = baseQuery.filter{ case (_, g1, g2) =>
  g1.filter(_.status === "playing").isDefined || g2.filter(_.status =!= "gameOver").isDefined
}

注意在left join中，g1和g2是Option类型，因此isDefined适用于or操作。

单独说明一下，鉴于您的过滤条件仅针对 PlayerGameTable，在 join 之前执行 filtering 可能会更有效。

Scala Slick joinLeft 和组合条件

Scala Slick joinLeft and combined conditions

scala

playframework

slick