为什么我不能在 slick 查询中使用 Options

Question

为了省去我创建这么多方法的麻烦，我尝试将 Option 传递到我的方法中，然后检查是否定义了 Option，如果是，则应用过滤器。

def getUsers(locationId: Option[Int], companyId: Int, salary: Option[Int]): List[User] = {
  val query = for {
    u <- users if u.companyId === companyId && (locationId.isDefined && u.locationId === locationId.get) && (salary.isDefined && u.salary >= salary.get)

  }
  query.list()
}

我收到错误消息：

polymorphic expression cannot be instantiated to expected type;

IntelliJ errors are expected Boolean actual Column[Boolean].

这种类型的子句是不是在一个灵活的查询中是不可能的，还是我做错了？

Answer 1

我不能告诉你为什么，但这是为我编译的：

def getUsers(locationId: Option[Int], companyId: Int, salary: Option[Int]): List[User] = {
  val query = for {
    u <- users if u.companyId === companyId && locationId.isDefined && u.locationId === locationId.get && salary.isDefined && u.salary >= salary.get
  } yield(u)
  query.list()
}

请注意，没有括号，并且您必须 yield 一些东西，否则 query 的返回类型将是 Unit。

Answer 2

当然，在这里看不到任何问题，只需使用过滤器（或 withFilter）并映射选项即可。

def getUsers(locationId: Option[Int], companyId: Int, salary: Option[Int]): List[User] = (for {
  u <- users filter(u=>
    if (u.companyId === companyId.bind) && 
    (locationId.map(_.bind === u.locationId).getOrElse(true)) && 
    (salary.map(_.bind <= u.salary).getOrElse(true))
  )
} yield u).list()

使用过滤器可以让您下拉到 Scala 以获取地图或真正的后备表达式。如果您以u < users if... 开头，则无法使用Scala 条件。 bind 调用只是逃避潜在的恶意输入（即，如果参数来自应用程序外部）。

Answer 3

为什么它不起作用

正如 cvot 所指出的 in his comment，这不起作用的原因是：

Slick 将 None 翻译为 SQL NULL，包括 SQL 的 3 值逻辑 NULL 传播，因此 (None === a) 为 None 无论 a 的值如何...基本上如果表达式中的任何内容为 None，则整个表达式将为None，因此过滤器表达式将被视为false，查询结果将为空。

也就是说，有一种方法可以获得您想要的相同行为（仅在提供可选值时过滤）。

达到预期行为的方法

需要注意的关键是，Scala 将 for comprehension 编译为 map / flatMap / withFilter / filter 调用的组合。如果我理解正确的话，Slick 在将 Scala 推导式编译成 SQL 查询时可以使用结果结构。

这让我们可以分部分构建查询：

val baseQuery = for {
  u <- users if u.companyId === companyId
} yield u

val possiblyFilteredByLocation = if (locationId.isDefined) {
  baseQuery.withFilter(u => u.locationId === locationId.get
} else baseQuery

val possiblyFilteredBySalaryAndOrLocation = if (salary.isDefined) {
  possiblyFilteredByLocation.withFilter(u => u.salary >= salary.get)
} else possiblyFilteredByLocation

possiblyFilteredBySalaryAndOrLocation.list()

我们可以通过使用var 和fold 来简化这一过程：

var query = for {
  u <- users if u.companyId === companyId
} yield u
query = locationId.fold(query)(id => query.withFilter(u => u.locationId === id))
query = salary.fold(query)(salary => query.withFilter(u => u.salary >= salary))
query.list()

如果我们经常这样做，我们可以将Option 上的这种过滤模式概括为如下所示：

// Untested, probably does not compile
implicit class ConditionalFilter(query: Query) {
  def ifPresent[T](value: Option[T], predicate: (Query, T) => Query) = {
    value.fold(query)(predicate(query, _))
  }
}

然后我们可以将整个过滤器链简化为：

query
  .ifPresent[Int](locationId, (q, id) => q.withFilter(u => u.locationId === id))
  .ifPresent[Int](salary, (q, s) => q.withFilter(u => u.salary >= s))
  .list()

Answer 4

您可以使用以下解决方案（使用 Slick 3.3.x）：

def getUsers(locationId: Option[Int], companyId: Int, minSalary: Option[Int]) = 
  users.
    .filter(_.company === companyId)
    .filterOpt(locationId)(_.locationId === _)
    .filterOpt(minSalary)(_.salary >= _)

Answer 5

因为 Slick 查询被翻译成 SQL，它没有 Option 类的 isDefined 和 get 方法的概念。 但是您可以通过调用查询之外的方法并传递结果（通过选项上的 map 函数）来解决此问题。

下面的代码应该可以修复它：

def getUsers(locationId: Option[Int], companyId: Int, salary: Option[Int]): List[User] = {
    val locationAndSalary = for {
        locId <- locationId;
        sal <- salary
    } yield (locId, sal)

    locationAndSalary.map(locAndSal => {
        val query = for {
            u <- users if u.companyId === companyId && u.locationId === locAndSal._1 && u.salary >= locAndSal._2)  
        } yield u
        query.list()
    }).getOrElse(List[User]()) //If the locationID or salary is None, return empty list.
}

locationAndSalary 可能看起来很奇怪，但我们使用 for 推导式仅在 locationId 和 salary 都有值并将结果存储在元组中时才使用值，其中 locationId 位于第一个位置和工资在第二。以下链接对其进行了解释：Scala: for comprehensions with Options。

编辑：根据@Ende Neu 的回答，如果添加 yield 语句，代码会编译，但我仍然认为我的解决方案更像是“Scala 方式”。