Praktikat më të mira të Slick 3.0

Ju mund të ndani tabelën e hartës së shkëlqyeshme nga pyetjet e shkëlqyeshme. Vendosni tabelën e shkëlqyeshme të hartës në tipar. Përzieni këtë tipar ku dëshironi të shkruani pyetje dhe bashkohuni në tabelë. për shembull:

package com.knol.db.repo

import com.knol.db.connection.DBComponent
import scala.concurrent.Future

trait BankRepository extends BankTable { this: DBComponent =>

   import driver.api._

   def create(bank: Bank): Future[Int] = db.run { bankTableAutoInc += bank }

   def update(bank: Bank): Future[Int] = db.run { bankTableQuery.filter(_.id === bank.id.get).update(bank) }

   def getById(id: Int): Future[Option[Bank]] = db.run {   bankTableQuery.filter(_.id === id).result.headOption }

   def getAll(): Future[List[Bank]] = db.run { bankTableQuery.to[List].result }

   def delete(id: Int): Future[Int] = db.run { bankTableQuery.filter(_.id === id).delete }

 }

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

  import driver.api._

  private[BankTable] class BankTable(tag: Tag) extends Table[Bank](tag,"bank") {
     val id = column[Int]("id", O.PrimaryKey, O.AutoInc)
      val name = column[String]("name")
      def * = (name, id.?) <> (Bank.tupled, Bank.unapply)
    }

   protected val bankTableQuery = TableQuery[BankTable]

   protected def bankTableAutoInc = bankTableQuery returning bankTableQuery.map(_.id)

   }

 case class Bank(name: String, id: Option[Int] = None)

Për bashkimin e dy tabelave:

 package com.knol.db.repo

 import com.knol.db.connection.DBComponent
 import scala.concurrent.Future

 trait BankInfoRepository extends BankInfoTable { this: DBComponent =>

 import driver.api._

  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) }

  def getById(id: Int): Future[Option[BankInfo]] = db.run { bankInfoTableQuery.filter(_.id === id).result.headOption }

  def getAll(): Future[List[BankInfo]] = db.run { bankInfoTableQuery.to[List].result }

 def delete(id: Int): Future[Int] = db.run { bankInfoTableQuery.filter(_.id === id).delete }

 def getBankWithInfo(): Future[List[(Bank, BankInfo)]] =
  db.run {
  (for {
    info <- bankInfoTableQuery
    bank <- info.bank
  } yield (bank, info)).to[List].result
 }


  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._

private[BankInfoTable] 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 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)

   }

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

Për më shumë shpjegime, shihni Blog dhe github. Mund të jetë e dobishme!!!