SqlParser

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def array[T](columnPosition: Int)(implicit c: Column[Array[T]]): RowParser[Array[T]]

Parses specified array column.

def array[T](columnName: String)(implicit c: Column[Array[T]]): RowParser[Array[T]]

Parses specified array column.

import anorm.{ SQL, SqlParser }

val t: (String, Array[String]) = SQL"SELECT a, sqlArrayOfString FROM test"
  .as(SqlParser.str("a") ~
SqlParser.array[String]("sqlArrayOfString") map (
    SqlParser.flatten) single)

final def asInstanceOf[T0]: T0

def binaryStream(columnPosition: Int)(implicit c: Column[InputStream]): RowParser[InputStream]

Parses specified column as binary stream.

import java.io.InputStream
import anorm.{ SQL, SqlParser }

val parser = SqlParser.str(1) ~ SqlParser.binaryStream(2)
val file: (String, InputStream) = SQL("SELECT name, data FROM files").
  as(parser.single)

def binaryStream(columnName: String)(implicit c: Column[InputStream]): RowParser[InputStream]

Parses specified column as binary stream.

import java.io.InputStream
import anorm.{ SQL, SqlParser }

val parser = SqlParser.str("name") ~ SqlParser.binaryStream("data")
val file: (String, InputStream) = SQL("SELECT name, data FROM files").
  as(parser.single)

def bool(columnPosition: Int)(implicit c: Column[Boolean]): RowParser[Boolean]

Parses specified column as boolean.

def bool(columnName: String)(implicit c: Column[Boolean]): RowParser[Boolean]

Parses specified column as boolean.

import anorm.{ SQL, SqlParser }

val t: (Boolean, String) = SQL("SELECT a, b FROM test")
  .as(SqlParser.bool("a") ~ SqlParser.str("b") map (
    SqlParser.flatten) single)

def byte(columnPosition: Int)(implicit c: Column[Byte]): RowParser[Byte]

Parses specified column as byte.

def byte(columnName: String)(implicit c: Column[Byte]): RowParser[Byte]

Parses specified column as byte.

import anorm.{ SQL, SqlParser }

val t: (Byte, String) = SQL("SELECT a, b FROM test")
  .as(SqlParser.byte("a") ~ SqlParser.str("b") map (
    SqlParser.flatten) single)

def byteArray(columnPosition: Int)(implicit c: Column[Array[Byte]]): RowParser[Array[Byte]]

Parses specified column as binary stream.

import anorm.{ SQL, SqlParser }

val parser = SqlParser.str(1) ~ SqlParser.byteArray(2)
val file: (String, Array[Byte]) = SQL("SELECT name, data FROM files").
  as(parser.single)

def byteArray(columnName: String)(implicit c: Column[Array[Byte]]): RowParser[Array[Byte]]

Parses specified column as binary stream.

import anorm.{ SQL, SqlParser }

val parser = SqlParser.str("name") ~ SqlParser.byteArray("data")
val file: (String, Array[Byte]) = SQL("SELECT name, data FROM files").
  as(parser.single)

def clone(): AnyRef

def date(columnPosition: Int)(implicit c: Column[Date]): RowParser[Date]

Parses specified column as date.

def date(columnName: String)(implicit c: Column[Date]): RowParser[Date]

Parses specified column as date.

import anorm.{ SQL, SqlParser }

val t: (Date, String) = SQL("SELECT a, b FROM test")
  .as(SqlParser.date("a") ~ SqlParser.str("b") map (
    SqlParser.flatten) single)

def double(columnPosition: Int)(implicit c: Column[Double]): RowParser[Double]

Parses specified column as double.

def double(columnName: String)(implicit c: Column[Double]): RowParser[Double]

Parses specified column as double.

import anorm.{ SQL, SqlParser }

val t: (Double, String) = SQL("SELECT a, b FROM test")
  .as(SqlParser.double("a") ~ SqlParser.str("b") map (
    SqlParser.flatten) single)

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def flatten[T1, T2, R](implicit f: TupleFlattener[(~[T1, T2]) ⇒ R]): (~[T1, T2]) ⇒ R

Flatten columns tuple-like.

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

val tuple: (Long, String, Int) = SQL("SELECT a, b, c FROM Test").
  as(long("a") ~ str("b") ~ int("c") map (SqlParser.flatten) single)

def float(columnPosition: Int)(implicit c: Column[Float]): RowParser[Float]

Parses specified column as float.

def float(columnName: String)(implicit c: Column[Float]): RowParser[Float]

Parses specified column as float.

import anorm.{ SQL, SqlParser }

val t: (Float, String) = SQL("SELECT a, b FROM test")
  .as(SqlParser.float("a") ~ SqlParser.str("b") map (
    SqlParser.flatten) single)

def get[T](position: Int)(implicit extractor: Column[T]): RowParser[T]

Returns row parser for column at given position.

def get[T](name: String)(implicit extractor: Column[T]): RowParser[T]

Returns row parser for column with given name.

final def getClass(): Class[_]

def hashCode(): Int

def int(columnPosition: Int)(implicit c: Column[Int]): RowParser[Int]

Parses specified column as integer.

def int(columnName: String)(implicit c: Column[Int]): RowParser[Int]

Parses specified column as integer.

import anorm.{ SQL, SqlParser }

val t: (Int, String) = SQL("SELECT a, b FROM test")
  .as(SqlParser.int("a") ~ SqlParser.str("b") map (
    SqlParser.flatten) single)

final def isInstanceOf[T0]: Boolean

def list[T](columnPosition: Int)(implicit c: Column[List[T]]): RowParser[List[T]]

Parses specified array column as list.

def list[T](columnName: String)(implicit c: Column[List[T]]): RowParser[List[T]]

Parses specified array column as list.

import anorm.{ SQL, SqlParser }

val t: (String, List[String]) = SQL("SELECT a, sqlArrayOfString FROM test")
  .as(SqlParser.str("a") ~ SqlParser.list("sqlArrayOfString") map (
    SqlParser.flatten) single)

def long(columnPosition: Int)(implicit c: Column[Long]): RowParser[Long]

Parses specified column as long.

def long(columnName: String)(implicit c: Column[Long]): RowParser[Long]

Parses specified column as long.

import anorm.{ SQL, SqlParser }

val t: (Long, String) = SQL("SELECT a, b FROM test")
  .as(SqlParser.long("a") ~ SqlParser.str("b") map (
    SqlParser.flatten) single)

def matches[TT, T <: TT](column: String, value: T)(implicit arg0: Column[TT], c: Column[TT]): RowParser[Boolean]

Returns row parser which true if specified column is found and matching expected value.

import anorm.SQL
import anorm.SqlParser.matches

val m: Boolean = SQL("SELECT * FROM table").as(matches("a", 1.2f).single)
// true if column |a| is found and matching 1.2f, otherwise false

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def scalar[T](implicit transformer: Column[T]): RowParser[T]

Returns parser for a scalar not-null value.

val count = SQL("select count(*) from Country").as(scalar[Long].single)

def short(columnPosition: Int)(implicit c: Column[Short]): RowParser[Short]

Parses specified column as short.

def short(columnName: String)(implicit c: Column[Short]): RowParser[Short]

Parses specified column as short.

import anorm.{ SQL, SqlParser }

val t: (Short, String) = SQL("SELECT a, b FROM test")
  .as(SqlParser.short("a") ~ SqlParser.str("b") map (
    SqlParser.flatten) single)

def str(columnPosition: Int)(implicit c: Column[String]): RowParser[String]

Parses specified column as string.

def str(columnName: String)(implicit c: Column[String]): RowParser[String]

Parses specified column as string.

import anorm.{ SQL, SqlParser }

val t: (Float, String) = SQL("SELECT a, b FROM test")
  .as(SqlParser.float("a") ~ SqlParser.str("b") map (
    SqlParser.flatten) single)

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 contains[TT, T <: TT](column: String, value: T)(implicit arg0: Column[TT]): RowParser[Unit]

Returns row parser which throws exception if specified column is either missing or not matching expected value.

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

val parser = contains("a", true) ~ str("b") map {
  case () ~ str => str
}

SQL("SELECT * FROM table").as(parser.+)
// Throws exception if there no |a| column or if |a| is not true,
// otherwise parses as non-empty list of |b| strings.

def getAliased[T](aliasName: String)(implicit extractor: Column[T]): RowParser[T]