WorkingWithSlick2.1.0

SSlliicckk 22..11..00
Satendra Kumar
Software Consultant
Knoldus Software LLP

TTooppiiccss CCoovveerreedd
What is slick
Table definition
Queries and Joins
Query extensions
Nested Mapped entity
Unit testing with H2 database
Live Demo

What is Slick
for{e ← Employees} yield e “select * from employee”
● Slick is a library written in scala for talking to database from scala programs.
● It is currently based on Jdbc.
● It is Successor of ScalaQuery.
● Developed By Typesafe and EPFL(École Polytechnique Fédérale de Lausanne)

Table Definition
class KnolTable(tag: Tag) extends Table[(String, String, Date, Int)](tag, "knol") {
def id: Column[Int] = column[Int]("id", O.PrimaryKey, O.AutoInc)
def name: Column[String] = column[String]("name", O.NotNull)
def email: Column[String] = column[String]("email", O.NotNull)
def dob: Column[Date] = column[Date]("dob", O.NotNull)
def * = (name, email, dob, id)
}
val knolTable = TableQuery[KnolTable]

Custom Row Types
case class Knol(name: String, email: String, dob: java.sql.Date, id: Int = 0)
class KnolTable(tag: Tag) extends Table[Knol](tag, "knol") {
def dob: Column[java.sql.Date] = column[java.sql.Date]("dob", O.NotNull)
def * = (name, email, dob, id) <> (Knol.tupled, Knol.unapply)
}

Custom Column Types
case class Knol(name: String, email: String, dob: java.util.Date, id: Int = 0)
implicit val util2sqlDateMapper = MappedColumnType.base[java.util.Date,
java.sql.Date](
{ utilDate => new java.sql.Date(utilDate.getTime()) },
{ sqlDate => new java.util.Date(sqlDate.getTime()) })
def dob: Column[java.util.Date] = column[java.util.Date]("dob", O.NotNull)
}

Foreign Keys
case class KnolX(topic: String, date: Date, knolId: Int, id: Int = 0)
class KnolXTable(tag: Tag) extends Table[KnolX](tag, "knolx") {
def topic: Column[String] = column[String]("topic", O.NotNull)
def date: Column[Date] = column[Date]("date", O.NotNull)
def knolId: Column[Int] = column[Int]("knol_id", O.NotNull)
def * = (topic, date, knolId, id) <> (KnolX.tupled, KnolX.unapply)
def fKey = foreignKey("knol_x_fk", knolId, knolTable)(_.id)
}
val knolSession = TableQuery[KnolXTable]

Table Creation And Data Insertion
// ddl
(knolTable.ddl ++ knolXTable.ddl).create
// insert a record
knolTable.insert(Knol("saurabh", "saurabh@knoldus.com", new Date("01/07/1985")))
knolTable +=Knol("saurabh", "saurabh@knoldus.com", new Date("01/07/1985"))
// insert List of record
val list=List(Knol("saurabh", "saurabh@knoldus.com", new Date("01/07/1985")))
knolTable.insertAll(list:_*)
knolTable ++=list

Auto Generated Keys
val knolAutoInc = knolTable returning knolTable.map(_.id)
val kId =
knolAutoInc.insert(Knol("anand", "anand@knoldus.com", new Date("01/07/1986")))
knolXTable.insert(KnolX("play framework", new Date("03/05/2014"), kId))
knolXTable.insert(KnolX("Anorm", new Date("07/23/2014"), kId))

Types in Slick
}
val query: Query[Column[String], String, Seq] =
knolTable.map((knol: KnolTable) => knol.name: Column[String])
val knolList: Seq[String] = query.run(session)

Update and Delete
//update name of knol which have id =2
val updatedObj = Knol("Anand Singh", "anand@knoldus.com", new Date("01/07/1986"))
knolTable.filter { knol => knol.id === 2 }.update(updatedObj)
* This is not good because we updating complete row instead on one column So :
knolTable.filter { knol => knol.id === 2 }.map(_.name).update("Anand Singh")
// delete record of id=2
knolTable.filter { knol => knol.id === 2 }.delete

Sorting , Filtering and Pagination
// ascending sorting
val sortedList = knolTable.sortBy(knol => knol.name.asc).list
// descending sorting
val reverseSortedList = knolTable.sortBy(knol => knol.name.desc).list
//filtering
val filteredList = knolTable.filter {
knol => knol.dob < (new Date("01/07/1988"))
}.map(_.name).list
// pagination
val page = knolTable.drop(2).take(1).list

Compiled Queries
Database queries typically depend on some parameters, e.g. an ID for which you want to
retrieve a matching database row. You can write a regular Scala function to create a
parameterized Query object each time you need to execute that query but this will
incur the cost of recompiling the query in Slick.
def getKnolCompiledQuery = {
Compiled(
(knolId: Column[Int]) =>
for { knol <- knolTable.filter(_.id === knolId) } yield (knol))
}
getKnolCompiledQuery(2).list

Inner join
/** implicit inner join */
val implicitInnerQuery = for {
knol: KnolTable <- knolTable
knolX: KnolXTable <- knolXTable if (knolX.knolId === knol.id)
} yield (knol, knolX)
/** explicit inner join */
val innerQuery = for {
(knol, knolX) <- knolTable innerJoin knolXTable on (_.id === _.knolId)
OR
val innerQuery = knolTable innerJoin knolXTable on (_.id === _.knolId)

Left Join
val leftJoinQuery = for {
(knol, knolX) <- knolTable leftJoin knolXTable on (_.id === _.knolId)
OR
val leftJoinQuery = knolTable leftJoin knolXTable on (_.id === _.knolId)
In left join, right-hand side have some additional null. So to avoid null
pointer exception use :
val leftJoin = for {
(knol, knolX) <- knolTable leftJoin knolXTable on (_.id === _.knolId)
} yield (knol, (knolX.topic.?, knolX.date.?, knolX.knolId.?, knolX.id.?))

Right Join
val rightJoin = for {
(knol, knolX) <- knolTable rightJoin knolXTable on (_.id === _.knolId)
OR
val rightJoin = knolTable rightJoin knolXTable on (_.id === _.knolId)
.
In right join, left-hand side have some additional null. So to avoid null pointer
exception use :
val rightJoin = for {
(knol, knolX) <- knolTable rightJoin knolXTable on (_.id === _.knolId)
} yield ((knol.name.?, knol.email.?, knol.dob.?,knol.id.?), knolX)

Full Outer Join
val fullOuterJoin = for {
(knol, knolX) <- knolTable outerJoin knolXTable on (_.id === _.knolId)
OR
val fullOuterJoin1 = knolTable outerJoin knolXTable on (_.id === _.knolId)
/** Full outer join have additional null both right and left side.*/
val fullOuterJoin = for {
(knol, knolX) <- knolTable outerJoin knolXTable on (_.id === _.knolId)
} yield (
(knol.name.?, knol.email.?, knol.dob.?, knol.id.?),
(knolX.topic.?, knolX.date.?, knolX.knolId.?, knolX.id.?))

Query Extension
implicit class QueryExtension1[T1, E1](val q: Query[T1, E1, Seq]) {
def page(no: Int, pageSize: Int = 2): Query[T1, E1, Seq] =
q.drop((no - 1) * pageSize).take(pageSize)
}
knolTable.page(2).list

Query Extensions for Table
implicit class QueryExtension2[T1, E1](val q: Query[KnolTable, Knol, Seq]) {
def sortByName: Query[Column[String], String, Seq] =
q.map(_.name).sortBy(_.asc)
}
knolTable.sortByName.run(session)

Query Extensions for Join
def joinInner[T2, E2](s: Query[T2, E2, Seq])(
condition: (T1, T2) => Column[Boolean]): Query[(T1, T2), (E1, E2), Seq] =
q.innerJoin(s).on(condition)
}
val condition = (k: KnolTable, x: KnolXTable) => k.id === x.knolId
knolTable.joinInner(knolXTable)(condition).list

Auto Joins
def autoJoin[T2, E2](s: Query[T2, E2, Seq])(
condition: (T1, T2) => Column[Boolean]): Query[(T1, T2), (E1, E2), Seq] =
q.join(s).on(condition)
}
val condition = (k: KnolTable, x: KnolXTable) => k.id === x.knolId
knolTable.autoJoin(knolXTable)(condition).list

Query extensions summary
• Mindshift required!
Think code, not monolithic query strings.
• Stay completely lazy!
Keep Query[...]s as long as you can.
• Re-use!
Write query functions or extensions methods for shorter, better and DRY code.

Nested Mapped entity
case class Address(locationId: Int, location: String)
case class Knol(name: String, email: String, address: Address, id: Int = 0)
def locationId: Column[Int] = column[Int]("location_id")
def location: Column[Int] = column[String]("location")
def address = (locationId, location) <> (Address.tupled, Address.unapply)
def * = (name, email, address, id) <> (Knol.tupled, Knol.unapply)
}

import scala.slick.driver.H2Driver.simple._
trait KnolRepositoryComponent{
}
def insert(knol: Knol) = {
DB.getConnection.withSession { implicit session: Session =>
knolTable.insert(knol) }
}
}
object DB{
def getConnection(): Database=
Database.forURL("jdbc:h2:mem:test", driver = "org.h2.Driver")
}
What is wrong with design ?

import scala.slick.driver.H2Driver.simple._
trait KnolRepositoryComponent {
}
DB.getConnection.withSession { implicit session: Session => knolTable.insert(knol) }
}
}
object DB {
def getConnection(): Database =
Database.forURL("jdbc:h2:mem:test", driver = "org.h2.Driver")
}
This is database specific code

Slick Database Driver Hierarchy

Driver Level Abstraction
import scala.slick.driver.JdbcProfile
trait DBComponent {
val driver: JdbcProfile
import driver.simple._
def dbObject(): Database
}

Driver Level Abstraction
trait KnolRepositoryComponent { this: DBComponent =>
def dob: Column[Date] = column[java.util.Date]("dob", O.NotNull)
}
def insert(knol: Knol): Int =
dbObject.withSession { implicit session: Session =>
knolTable.returning(knolTable.map(_.id)).insert(knol)
}
def update(knol: Knol): Int =
dbObject.withSession { implicit session: Session => knolTable.filter { _.id ===
knol.id }.update(knol) }
def delete(id: Int): Int =
dbObject.withSession { implicit session: Session => knolTable.filter { _.id === id }.delete }
}

Driver Specific Implementation
import scala.slick.driver.PostgresDriver
import com.typesafe.config.ConfigFactory
trait PostgresDBComponent extends DBComponent {
val driver = PostgresDriver
private val config = ConfigFactory.load()
private val dbDriver = config.getString("db.driver")
private val url = config.getString("db.url")
private val host = config.getString("db.host")
private val port = config.getInt("db.port")
private val database = config.getString("db.database")
private val userName = config.getString("db.username")
private val password = config.getString("db.password")
private val combindURL = url + host + ":" + port + "/" + database
def dbObject(): Database =
Database.forURL(combindURL, userName, password, null, dbDriver)
}

For Production Usage
trait KnolRepositoryComponent { this: DBComponent =>
def dob: Column[Date] = column[java.util.Date]("dob", O.NotNull)
}
dbObject.withSession { implicit session: Session => knolTable.insert(knol) }
}
}
object KnolRepository extends KnolRepositoryComponent with PostgresDBComponent

Test Specific implementation
import scala.slick.driver.H2Driver
import com.typesafe.config.ConfigFactory
import org.slf4j.LoggerFactory
trait TestDBComponent extends DBComponent {
val logger = LoggerFactory.getLogger(this.getClass())
val driver = H2Driver
private val config = ConfigFactory.load()
private val dbDriver = config.getString("db.driver")
private val url = config.getString("db.url")
def dbObject(): Database = {
logger.debug(s"URL :[$url] driver: [$driver]")
Database.forURL(url, driver = dbDriver)
}
}

Unit Test Using H2 database
class KnolRepositoryTest extends FunSuite with KnolRepositoryComponent with TestDBComponent
{
test("Get all knol info") {
assert(getKnolList.length === 4)
}
test("Add new Knol info") {
val knol = Knol("test", "test@knoldus.com", new Date("01/07/1986"))
assert(insert(knol) === 5)
}
test("Update knol info") {
val updatedKnol = Knol("Anand singh", "anand@knoldus.com", new Date("01/07/1986"), 1)
assert(update(updatedKnol) === 1)
}
test("Delete Knol info") {
assert(delete(1) === 1)
}
}

References
1. Slick documentation
http://slick.typesafe.com/doc/2.1.0/
2.Patterns for Slick database applications
https://skillsmatter.com/skillscasts/4577-patterns-for-slick-database-applications

WorkingWithSlick2.1.0

Recommended

Recommended

More Related Content

What's hot

What's hot (19)

Similar to WorkingWithSlick2.1.0

Similar to WorkingWithSlick2.1.0 (20)

More from Knoldus Inc.

More from Knoldus Inc. (20)

Recently uploaded

Recently uploaded (20)

WorkingWithSlick2.1.0