Anorm Primer

· 2 min read

Typically, you would read the results of an Anorm query, and map to a already defined type - case class, something like this:

val persons: List[Person] =
  SQL("select id from ....")
    .on(...)
    .getRows()
    .map(toPerson)

final case class Person(id: Int, name: String, weight: Float)

def toPerson(row: Row): Person =
  Person(
    row[Int]("id"),
    row[String]("name"),
    row[Float]("weight"),
  )

There are times when you would want to read a single column. Or perhaps a set of columns for which you don’t have a pre-defined type (like Person above). In such cases, you will toil as follows:

val ids: List[Int] =
SQL("select id from ....")
    .on(...)
    .getRows()
    .map(row => row[Int]("id"))

// or

val ps: List[(Int, String)] =
  SQL("select id from ....")
    .on(...)
    .getRows()
    .map { row =>
      (
        row => row[Int]("id"),
        row => row[String]("name")
      )
    }

Note that the following is different from what we are discussing here.

// NOTE: We are not talking about this !!!
val count: Long = SQL("select count(*) from users").as(scalar[Long].single)

Using core Anorm functions

import anorm.{SQL, SqlParser}, SqlParser.{int, str, to}

val result: List[Int] =
  SQL("select id from persons where ...")
    .on(...)
    .as(int("id"))

val result: List[Int ~ String] =    // Anorm's type `~` for chanining types (much like shapeless HList)
  SQL("select id, name from ....")
    .on(...)
    .as(int("id") ~ str("name"))

Anorm’s parser combinators 101

Extracting a reusable parser for your query

val resultSetParser: ResultSetParser[List[Int ~ String]] = int("id") ~ str("name")

val parser: ResultSetParser[List[(Int, String)]] =
  resultSetParser.map { case n ~ p => (n, p) }

// Shorthand of the above using built-in `flatten` function
val parser: ResultSetParser[List[(Int, String)]] =
  resultSetParser.map(flatten).*

// The finishing touch!
val result: Map[Int, String] =
  SQL(query)
    .on(...)
    .as(parser)  // List[(Int, String)]
    .toMap

A Bit More of Anorms’ Parser Combinators

Anorm provides a bunch of other parser combinators. Check Anorm’s documentation for more details but here is a teaser:

Explicit control of how much to read from the ResultSet

val parser: ResultSetParser[List[(String, Int)]] =
  for {
    name <- str("name")
    age  <- int("age")
  } yield name -> age


val exactlyOne: (String, Int)         = SELECT("select ...").as(parser.single)
val zeroOneOrMore: List[(String, Int) = SQL("select ...").as(parser.*)
val oneOrMore: List[(String, Int)     = SQL("select ...").as(parser.+)

The to combinator to the rescue

import anorm.SqlParser.{ int, str, to }

def show(name: String, age: Int): String =  s"...."

val parser: ResultSetParser[List[(String, Int)]] =
  str("name") ~ int("age").map(to(show _))

Parser using Pattern matching

val parser: ResultSetParser[List[(String, Int, Boolean)]] =
  str("name") ~ int("age") ~ str("millionaire").map {
    case n ~ l ~ "T" => (n, l, true)
    case n ~ l ~ "F" => (n, l, false)
  }.*