使用 Scala Slick 实现高阶函数，实现 DRY 优点

我知道我的 Scala Slick 数据访问层应该是什么样子，但我不确定这是否真的可能。

假设我有一个 User 表，其中包含 id、电子邮件、密码等常用字段。

  object Users extends Table[(String, String, Option[String], Boolean)]("User") {
    def id = column[String]("id", O.PrimaryKey)
    def email = column[String]("email")
    def password = column[String]("password")
    def active = column[Boolean]("active")
    def * = id ~ email ~ password.? ~ active
  }

我希望以不同的方式查询它们，目前丑陋的方式是有一个新的数据库会话，进行 for 理解，然后执行不同的 if 语句来实现我想要的。

e.g.

  def getUser(email: String, password: String): Option[User] = {
    database withSession { implicit session: Session =>
      val queryUser = (for {
        user <- Users
          if user.email === email &&
             user.password === password &&
             user.active === true
      } //yield and map to user class, etc...
  }

  def getUser(identifier: String): Option[User] = {
    database withSession { implicit session: Session =>
      val queryUser = (for {
        user <- Users
        if user.id === identifier &&
           user.active === true
      } //yield and map to user class, etc...
  }

我更喜欢的是有一个用于查询的私有方法，然后是沿着以下方式定义查询的公共方法

type UserQuery = User => Boolean

private def getUserByQuery(whereQuery: UserQuery): Option[User] = {
  database withSession { implicit session: Session =>
      val queryUser = (for {
        user <- Users
          somehow run whereQuery here to filter
      } // yield and boring stuff
  }

def getUserByEmailAndPassword(email, pass){ ... define by query and call getUserByQuery ...}

getUserById(id){….}

getUserByFoo{….} 

这样，查询逻辑就被封装在相关的公共函数中，而实际的查询和到用户对象的映射是在一个其他人不需要关心的可重用函数中。

我遇到的问题是尝试将“where”位重构为我可以传递的函数。尝试做一些事情，比如在 intellij 中选择它们并使用重构会导致一些非常疯狂的打字。

有没有人有任何例子可以展示他们所做的接近我想要实现的目标？

1) 将查询包装在 def 中意味着查询语句会在每个请求上重新生成，并且由于查询参数未绑定，因此不会将准备好的语句传递到底层 DBMS。

2）你没有利用组合的优势

相反，如果您定义 def 查询包装器调用的参数化查询值，则可以两全其美。

val uBase = for{
  u  <- Users
  ur <- UserRoles if u.id is ur.UserID
} yield (u,ur)

// composition: generates prepared statement one time, on startup
val byRole = for{ roleGroup <- Parameters[String]
  (u,ur) <- uBase
  r <- Roles if(r.roleGroup is roleGroup) && (r.id is ur.roleID)
} yield u

def findByRole(roleGroup: RoleGroup): List[User] = {
  db withSession { implicit ss:SS=>
    byRole(roleGroup.toString).list
  }
}

如果您需要一次性查找单个房产，请使用：

val byBar = Foo.createFinderBy(_.bar)
val byBaz = Foo.createFinderBy(_.baz)

不记得在哪里了，也许是在 SO 或 Slick 用户组上，但我确实看到了一个非常有创意的解决方案，它允许多个绑定参数，基本上是一个createFinderBy使用类固醇。但对我来说不太有用，因为解决方案仅限于单个映射器/表对象。

无论如何，为理解而写作似乎可以实现您想要做的事情。