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

Filtering using Scala Parser Combinators

Filtering using Scala Parser Combinators So I got interesting task to enable record filtering according to some rules that we get from configuration represented as text. well so far we know two things : 1. we need a filter that accepts a record as an input and might return a record as its output : def filter ( record : Record ) : Option [ Record ] 2. we need to get a text with some kind of rule e.g  "foo = 'FOO'" , "bar = 8", "buz IS NOT NULL "  and AND / OR combinations . where foo/bar/buz are record's attributes * well I know that "null" is a dirty word in FP but that was the requirement since it was a mix-in with java project. Following  the rule of three  so is our todo list : parse the text evaluate it's Boolean expression in a form of Abstract Syntax Tree. filter according the Boolean evaluation. The complete Source Code can be found  here  (you are more than welcome to contribute ) Parser Combin...
Read more

Simple and useful Zip and unZip text

Simple and usefull textual zip and unzip. First we use binary zip . but if we want to send it as a text message (e.g some message bus supports only text messages) we need to convert it to text by encoding to base 64 and vice versa to unzip it. import java.io.ByteArrayInputStream import java.nio.charset.StandardCharsets import java.util.zip.{GZIPOutputStream, GZIPInputStream} import org.apache.commons.codec.binary.Base64 import org.apache.commons.io.output.ByteArrayOutputStream import scala.util.Try val zipToBinary: String => Array[Byte] = {txt => val arrOutputStream = new ByteArrayOutputStream() val zipOutputStream = new GZIPOutputStream(arrOutputStream) zipOutputStream.write(txt.getBytes(StandardCharsets.UTF_8)) zipOutputStream.close() arrOutputStream.toByteArray } val byteArrayToTxt : Array[Byte] => String = bytes => Base64.encodeBase64String(bytes) val txtToBinary : String => Array[Byte]= txt => Base64.decodeBase64(txt.getBytes(Sta...
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 o...
Read more