ScalarRowParser

abstract def apply(v1: Row): SqlResult[A]

final def !=(arg0: Any): Boolean

final def ##(): Int

def *: ResultSetParser[List[A]]

Returns possibly empty list parsed from result.

val price = 125
SQL"SELECT name FROM item WHERE price < $price".as(scalar[String].*)

def +: ResultSetParser[List[A]]

Returns non empty list parse from result, or raise error if there is no result.

import anorm.SQL
import anorm.SqlParser.str

val parser = str("title") ~ str("descr")
SQL("SELECT title, descr FROM pages").as(parser.+) // at least 1 page

def <~[B](p: RowParser[B]): RowParser[A]

final def ==(arg0: Any): Boolean

def >>[B](f: (A) ⇒ RowParser[B]): RowParser[B]

def ?: RowParser[Option[A]]

Returns a row parser for optional column, that will turn missing or null column as None.

def andThen[A](g: (SqlResult[A]) ⇒ A): (Row) ⇒ A

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def collect[B](otherwise: String)(f: PartialFunction[A, B]): RowParser[B]

Returns parser which collects information from already parsed row data using f.

def compose[A](g: (A) ⇒ Row): (A) ⇒ SqlResult[A]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def flatMap[B](k: (A) ⇒ RowParser[B]): RowParser[B]

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def map[B](f: (A) ⇒ B): RowParser[B]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def single: ResultSetParser[A]

Returns a result set parser expecting exactly one row to parse.

val b: Boolean = SQL("SELECT flag FROM Test WHERE id = :id").
on("id" -> 1).as(scalar[Boolean].single)

def singleOpt: ResultSetParser[Option[A]]

Returns a result set parser for none or one parsed row.

val name: Option[String] =
SQL("SELECT name FROM Country WHERE lang = :lang")
.on("lang" -> "notFound").as(scalar[String].singleOpt)

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def |[B >: A](p: RowParser[B]): RowParser[B]

def ~[B](p: RowParser[B]): RowParser[~[A, B]]

def ~>[B](p: RowParser[B]): RowParser[B]