RowParser

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]

Combines this current parser with the one given as argument p, if and only if the current parser can first successfully parse a row, without keeping the values of the parser p.

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

val Int = SQL("SELECT * FROM test").
  as((int("id") <~ str("val")).single)
// row has to have an int column 'id' and a string 'val' one,
// keeping only 'id' in result

final def ==(arg0: Any): Boolean

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

Alias for flatMap

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]

Returns a parser that will apply given function f to the result of this first parser.

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]]

Combines this parser on the left of the parser p given as argument.

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

Combines this current parser with the one given as argument p, if and only if the current parser can first/on left side successfully parse a row, without keeping these values in parsed result.

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

val String = SQL("SELECT * FROM test").
  as((int("id") ~> str("val")).single)
// row has to have an int column 'id' and a string 'val' one,
// keeping only 'val' in result