Play Framework/Scala example source code file (Row.scala)

This example Play Framework source code file (Row.scala) is included in my "Source Code Warehouse" project. The intent of this project is to help you more easily find Play Framework (and Scala) source code examples by using tags.

All credit for the original source code belongs to Play Framework; I'm just trying to make examples easier to find. (For my Scala work, see my Scala examples and tutorials.)

Play Framework tags/keywords

any, column, list, map, mayerr, metadataitem, metatuple, option, play, play framework, row, string

The Row.scala Play Framework example source code

package anorm

trait Row {
  val metaData: MetaData

  /** Raw data */
  private[anorm] val data: List[Any]

  /**
   * Returns row as list of column values.
   *
   * {{{
   * // Row first column is string "str", second one is integer 2
   * val l: List[Any] = row.asList
   * // l == List[Any]("str", 2)
   * }}}
   */
  lazy val asList: List[Any] = data.foldLeft[List[Any]](Nil) { (l, v) =>
    if (metaData.ms(l.size).nullable) l :+ Option(v) else l :+ v
  }

  /**
   * Returns row as dictionary of value per column name
   *
   * {{{
   * // Row column named 'A' is string "str", column named 'B' is integer 2
   * val m: Map[String, Any] = row.asMap
   * // l == Map[String, Any]("table.A" -> "str", "table.B" -> 2)
   * }}}
   */
  lazy val asMap: Map[String, Any] =
    data.foldLeft[Map[String, Any]](Map.empty) { (m, v) =>
      val d = metaData.ms(m.size)
      val k = d.column.qualified
      if (d.nullable) m + (k -> Option(v)) else m + (k -> v)
    }

  private def get[A](a: String)(implicit c: Column[A]): MayErr[SqlRequestError, A] = SqlParser.get(a)(c)(this) match {
    case Success(a) => Right(a)
    case Error(e) => Left(e)
  }

  /**
   * Returns parsed column.
   *
   * @param name Column name
   * @param c Column mapping
   *
   * {{{
   * import anorm.Column.columnToString // mapping column to string
   *
   * val res: (String, String) = SQL("SELECT * FROM Test").map(row =>
   *   row("code") -> row("label") // string columns 'code' and 'label'
   * )
   * }}}
   */
  def apply[B](name: String)(implicit c: Column[B]): B = get[B](name)(c).get

  // Data per column name
  private lazy val columnsDictionary: Map[String, Any] = {
    @annotation.tailrec
    def loop(meta: List[MetaDataItem], dt: List[Any], r: Map[String, Any]): Map[String, Any] = (meta, dt) match {
      case (m :: ms, d :: ds) => loop(ms, ds,
        r + (m.column.qualified.toUpperCase -> d))
      case _ => r
    }

    loop(metaData.ms, data, Map.empty)
  }

  // Data per column alias
  private lazy val aliasesDictionary: Map[String, Any] = {
    @annotation.tailrec
    def loop(meta: List[MetaDataItem], dt: List[Any], r: Map[String, Any]): Map[String, Any] = (meta, dt) match {
      case (m :: ms, d :: ds) => loop(ms, ds,
        m.column.alias.fold(r) { c => r + (c.toUpperCase -> d) })
      case _ => r
    }

    loop(metaData.ms, data, Map.empty)
  }

  /* Type alias for tuple extracted from metadata item */
  private type MetaTuple = (ColumnName, Boolean, String)

  private[anorm] def get1(a: String): MayErr[SqlRequestError, (Any, MetaDataItem)] = for (
    meta <- implicitly[MayErr[SqlRequestError, MetaTuple]](
      metaData.get(a).toRight(ColumnNotFound(a, metaData.availableColumns)));
    m = MetaDataItem.tupled(meta);
    data <- implicitly[MayErr[SqlRequestError, Any]](
      columnsDictionary.get(m.column.qualified.toUpperCase()).
        toRight(ColumnNotFound(
          m.column.qualified, metaData.availableColumns)))

  ) yield (data, m)

  private[anorm] def getAliased(a: String): MayErr[SqlRequestError, (Any, MetaDataItem)] = for (
    meta <- implicitly[MayErr[SqlRequestError, MetaTuple]](
      metaData.getAliased(a).toRight(
        ColumnNotFound(a, metaData.availableColumns)));
    m = MetaDataItem.tupled(meta);
    data <- implicitly[MayErr[SqlRequestError, Any]](
      m.column.alias.flatMap(a => aliasesDictionary.get(a.toUpperCase())).
        toRight(ColumnNotFound(m.column.alias.getOrElse(a),
          metaData.availableColumns)))

  ) yield (data, m)

  /** Try to get data matching index. */
  private[anorm] def getIndexed(i: Int): MayErr[SqlRequestError, (Any, MetaDataItem)] =
    for {
      m <- implicitly[MayErr[SqlRequestError, MetaDataItem]](
        metaData.ms.lift(i).toRight(
          ColumnNotFound(s"#${i + 1}", metaData.availableColumns)));
      d <- implicitly[MayErr[SqlRequestError, Any]](
        data.lift(i).toRight(
          ColumnNotFound(m.column.qualified, metaData.availableColumns)))
    } yield (d, m)

}

/** Companion object for row. */
object Row {

  /**
   * Row extractor.
   *
   * {{{
   * import java.util.Locale
   *
   * val l: Option[Locale] =
   *   SQL("Select name,population from Country")().collect {
   *     case Row("France", _) => Some(Locale.FRANCE)
   *     case _ => None
   *   }
   * }}}
   */
  def unapplySeq(row: Row): Option[List[Any]] = Some(row.asList)
}