上界爲油滑3.1.1查詢類型

Question

我有一個DAO輔助特徵，可提供通用功能的DAO。它需要能夠訪問表查詢並運行操作。我無法定義或以其他方式將查詢類型提供給助手特徵。

下面是一些代碼，在很短的demo project on GitHub也可在action分支。

trait DBComponent { 
    import slick.driver.JdbcProfile 

    val driver: JdbcProfile 
    import driver.api._ 

    val db: Database 
} 

的類被保留延長HasId：

trait HasId { 
    def id: Option[Int] = None 
} 

這裏是一個這樣的類被保留：

case class BankInfo(
    owner: String, 
    branches: Int, 
    bankId: Int, 
    override val id: Option[Int] = None 
) extends HasId 

問題 首先，db在性狀DBComponent定義是我不知道如何設置QueryType在以下DAO幫手特質;我預計大多數後面的錯誤是不當類型的結果，我用：

/** Handles all actions pertaining to HasId or that do not require parameters */ 
trait DbAction[T <: HasId] { this: DBComponent => 
    import driver.api._ // defines DBIOAction 

    type QueryType <: slick.lifted.TableQuery[Table[T]] // this type is wrong! What should it be? 
    def tableQuery: QueryType 

    // Is this defined correctly? 
    def run[R](action: DBIOAction[R, NoStream, Nothing]): Future[R] = db.run { action } 

    def deleteById(id: Option[Long]): Unit = 
    for { i <- id } run { tableQuery.filter(_.id === id).delete } // id is unknown because QueryType is wrong 

    def findAll: Future[List[T]] = run { tableQuery.to[List].result } // also b0rked 

    // Remaining methods shown on GitHub 
} 

僅供參考，這裏是如何在上述將被使用。首先，定義表查詢的特點：

trait BankInfoTable extends BankTable { this: DBComponent => 
    import driver.api._ 

    class BankInfoTable(tag: Tag) extends Table[BankInfo](tag, "bankinfo") { 
    val id  = column[Int]("id", O.PrimaryKey, O.AutoInc) 
    val owner = column[String]("owner") 
    val bankId = column[Int]("bank_id") 
    val branches = column[Int]("branches") 

    def bankFK = foreignKey("bank_product_fk", bankId, bankTableQuery)(_.id) 

    def * = (owner, branches, bankId, id.?) <> (BankInfo.tupled, BankInfo.unapply) 
    } 

    val tableQuery = TableQuery[BankInfoTable] 

    def autoInc = tableQuery returning tableQuery.map(_.id) 
} 

這一切都在這裏匯聚：

trait BankInfoRepositoryLike extends BankInfoTable with DbAction[BankInfo] 
{ this: DBComponent => 

    import driver.api._ 

    @inline def updateAsync(bankInfo: BankInfo): Future[Int] = 
    run { tableQuery.filter(_.id === bankInfo.id.get).update(bankInfo) } 

    @inline def getByIdAsync(id: Int): Future[Option[BankInfo]] = 
    run { tableQuery.filter(_.id === id).result.headOption } 
} 

建議？

Answer 1

你試圖抽象的過度的結果類型與HasId但你的代碼實際上並不關心這個。該id值，您使用的是那些從解除類型，即錶行類，所以你需要在這個級別的抽象：

trait LiftedHasId { 
    def id: slick.lifted.Rep[Int] 
} 

在 DbAction

然後：

type QueryType <: slick.lifted.TableQuery[_ <: Table[T] with LiftedHasId] 

而且BankInfoTable必須定義一個具體類型爲它：

type QueryType = slick.lifted.TableQuery[BankInfoTable] 

或者你可以將其添加爲的第二類型參數DbAction（就像Query具有用於提升型和結果類型2級類型的參數）。

Answer 2

全部工作示例：

package com.knol.db.repo 

import com.knol.db.connection.DBComponent 
import com.knol.db.connection.MySqlDBComponent 
import scala.concurrent.{Await, Future} 
import concurrent.duration.Duration 

trait LiftedHasId { 
    def id: slick.lifted.Rep[Int] 
} 

trait HasId { 
    def id: Option[Int] 
} 

trait GenericAction[T <: HasId]{this: DBComponent => 
    import driver.api._ 

    type QueryType <: slick.lifted.TableQuery[_ <: Table[T] with LiftedHasId] 

    val tableQuery: QueryType 

    @inline def deleteAsync(id: Int): Future[Int] = db.run { tableQuery.filter(_.id === id).delete } 
    @inline def delete(id: Int): Int = Await.result(deleteAsync(id), Duration.Inf) 

    @inline def deleteAllAsync(): Future[Int] = db.run { tableQuery.delete } 
    @inline def deleteAll(): Int = Await.result(deleteAllAsync(), Duration.Inf) 

    @inline def getAllAsync: Future[List[T]] = db.run { tableQuery.to[List].result } 
    @inline def getAll: List[T] = Await.result(getAllAsync, Duration.Inf) 

    @inline def getByIdAsync(id: Int): Future[Option[T]] = 
    db.run { tableQuery.filter(_.id === id).result.headOption } 

    @inline def getById(id: Int): Option[T] = Await.result(getByIdAsync(id), Duration.Inf) 

    @inline def deleteById(id: Option[Int]): Unit = 
    db.run { tableQuery.filter(_.id === id).delete } 

    @inline def findAll: Future[List[T]] = db.run { tableQuery.to[List].result } 




} 
trait BankInfoRepository extends BankInfoTable with GenericAction[BankInfo] { this: DBComponent => 

    import driver.api._ 

    type QueryType = TableQuery[BankInfoTable] 

    val tableQuery=bankInfoTableQuery 

    def create(bankInfo: BankInfo): Future[Int] = db.run { bankTableInfoAutoInc += bankInfo } 

    def update(bankInfo: BankInfo): Future[Int] = db.run { bankInfoTableQuery.filter(_.id === bankInfo.id.get).update(bankInfo) } 

    /** 
    * Get bank and info using foreign key relationship 
    */ 
    def getBankWithInfo(): Future[List[(Bank, BankInfo)]] = 
    db.run { 
     (for { 
     info <- bankInfoTableQuery 
     bank <- info.bank 
     } yield (bank, info)).to[List].result 
    } 

    /** 
    * Get all bank and their info.It is possible some bank do not have their product 
    */ 
    def getAllBankWithInfo(): Future[List[(Bank, Option[BankInfo])]] = 
    db.run { 
     bankTableQuery.joinLeft(bankInfoTableQuery).on(_.id === _.bankId).to[List].result 
    } 
} 

private[repo] trait BankInfoTable extends BankTable{ this: DBComponent => 

    import driver.api._ 

    class BankInfoTable(tag: Tag) extends Table[BankInfo](tag, "bankinfo") with LiftedHasId { 
    val id = column[Int]("id", O.PrimaryKey, O.AutoInc) 
    val owner = column[String]("owner") 
    val bankId = column[Int]("bank_id") 
    val branches = column[Int]("branches") 
    def bank = foreignKey("bank_product_fk", bankId, bankTableQuery)(_.id) 
    def * = (owner, branches, bankId, id.?) <> (BankInfo.tupled, BankInfo.unapply) 

    } 

    protected val bankInfoTableQuery = TableQuery[BankInfoTable] 

    protected def bankTableInfoAutoInc = bankInfoTableQuery returning bankInfoTableQuery.map(_.id) 

} 

object BankInfoRepository extends BankInfoRepository with MySqlDBComponent 

case class BankInfo(owner: String, branches: Int, bankId: Int, id: Option[Int] = None) extends HasId