Scala Migration 2.9 to 2.10 part 1 - from ScalaQuery to Slick

So , as it happens to be, migrating from scala 2.9 to 2.10 (And Akka,ScalaQuery) is not straight forward as one might think ...
for Akka upgrade I used this excellent document for migration 1.3.x to 2.0 and this on for migrating to 2.1

changing ScalaQuery to Slick is quite straight forward - changing the entities
i.e ScalaQuery (two columns as pk) :

  case class Foo_entity ( foo_id_col: String ,  foo_name_col: Long  )
  object  or_foo extends Table[Foo_entity]("foo") {
    def foo_id_col = column[String]("foo_id")
    def foo_name_col = column[Long]("foo_name")
    def pk = primaryKey("pk_foo",foo_id_col~foo_name_col)
    def * = foo_id_col ~ foo_name_col<>(Foo_entity,Foo_entity.unapply(_))
  }

in Slick turns to :

   case class Foo_entity ( foo_col: String ,  foo_name_col: Long  )
  class Foo(tag:Tag) extends Table[Foo_entity](tag,"foo") {
    def foo_col = column[String]("id")
    def foo_name_col = column[Long]("name")
    def pk = primaryKey("pk_round_player",(foo_col,foo_name_col))
    def * = (foo_col,foo_name_col)<>(Foo_entity.tupled,Foo_entity.unapply)
  }
  val or_foo = TableQuery[Foo]

or with single col as pk
case class Foo_entity ( foo_col: String ,  foo_name_col: Long  )
  class Foo(tag:Tag) extends Table[Foo_entity](tag,"foo") {
    def foo_col = column[String]("id",O.PrimaryKey)
    def foo_name_col = column[Long]("name")
       def * = (foo_col,foo_name_col)<>(Foo_entity.tupled,Foo_entity.unapply)
  }
  val or_foo = TableQuery[Foo]

writing queries with slick are more "Scalaish" and more functional so instead of writing this code with 
ScalaQuery :
  val db = Database.forDataSource(...)
 def getFooInfo(fooId: String):List[DB.foo_entity] = {
    val data = for{
      foo <- DB.or_foo if (foo.foo_id_col === fooId)
        _ <-Query.orderBy(foo.foo_order_col.asc)

    } yield foo

    db.withSession((s:Session) => {
      data.list()(s)
    })
  }

you can write in Slick :
  val db = Database.forDataSource(...)
def getFooInfo(fooId: String): List[DB.foo_entity] = {
    val data =DB.or_foo.filter(_.round_id_col === roundId).sortBy(_.foo_order_col.asc)
    db.withSession{implicit session =>
      data.list
    }
  }

also creating Transaction and getting the last id inserted is quite elegant with slick
ScalaQuery: 

   def lastInsertedId: Long = {
    val scopeIdentity = SimpleFunction.nullary[Long]("LAST_INSERT_ID")
    db.withSession((s: Session) => {
      Query(scopeIdentity).first()(s)
    })
  }

  def createTransaction(from: Long, to: Long, amount: Long): Long = {
    db.withTransaction((s: Session) => {
      DB.or_transaction.insert(DB.transaction_entity(None, from, to, amount, 0, null))(s)
      lastInsertedId
    })
  }

and Slick notice the use of the returning keyword:
def createTransaction(from: Long, to: Long, amount: Long): Long = {
    db.withTransaction{implicit session =>
      (or_transaction returning or_transaction.map(_.transaction_id_col.getOrElse(0))) +=transaction_entity(None, from, to, amount, 0, null)
    }
  }

Comments

Post a Comment

Popular posts from this blog

Building REST API web service using AKKA-HTTP, showing CRUD operations baked with Redis

Building REST API web service using AKKA-HTTP, showing CRUD operations baked with Redis AKKA-HTTP  is a lightweight layer that enable us to easily build our REST API over the akka actor system . In this article I will show step by step how to create simple web server with REST API Service and CRUD operations using  Rediscala  that will enable non-blocking and asynchronous I/O operations over Redis, sowing different options of completing the API response and serializing entities . And of course how to test our REST API. Full source code can be found  here Our web server will expose API for handling user passwords that will be kept in Redis (this is not a good practice to handle it like this in real life, and one might want to consider to add encryption etc’ in production). Our Rest API will expose the following functionality : Register new user Update user password Fetch user password Delete user So, let’s get our hands dirty First step — add dependencies to our Bu
Read more

Harness Scala Type Classes and Implicits

In my  previous blog , I presented an Expression ADT. In this article I will extend its functionality and serialize it using other ADT while maintaining decoupling using Scala's magic a.k.a implicits and type classes . Full code is in  this repository . Let's start by building our JSON serializer ADT sealed trait JSON case class JSeq ( elms : List [ JSON ]) extends JSON case class JObj ( bindings : Map [ String , JSON ]) extends JSON case class JNum ( num : Double ) extends JSON case class JStr ( str : String ) extends JSON case class JBool ( b : Boolean ) extends JSON case object JNull extends JSON and now we can create our JSONWriter to convert JSON objects to nice JSON String object JSONWriter { def write ( j : JSON ) : String = { j match { case JSeq ( e ) => e . map ( write ). mkString ( "[" , "," , "]" ) case JObj ( obj ) => obj . map ( o => &q
Read more

Playing with xml

XML is a convenient way to define external DSL. On one of my previous posts  ( Filtering using Scala Parser Combinators ) I used parser combinators  JavaTokenParsers with PackratParsers  This time I will use different approach using XML . XML is easy to handle by non-developers and easy to read. We can query XML using XPATH like expressions and using pattern matching. In this post we will define some business rules using XML and we will treat our XML as first class citizen. Source code can be found  here . let's define our DSL : Our rules will use AND/OR operators but to make it more interesting, our operators  will not use  the following pattern: <expression><operator><expression>  (where expression evaluates to boolean). because XML have opening and closing tags we can define something like : <operator><expression1><expression2>...<expression N></operator> now we can define our AND/OR operators : AND: a set of exp
Read more