Column

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def apply[A](transformer: (Any, MetaDataItem) ⇒ MayErr[SqlRequestError, A]): Column[A]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

implicit def columnToArray[T](implicit transformer: Column[T], t: ClassTag[T]): Column[Array[T]]

Parses column as array.

implicit val columnToBigInt: Column[BigInt]

Column conversion to big integer.

import anorm.SqlParser.scalar
import anorm.Column.columnToBigInt

val c: BigInt =
  SQL("SELECT COUNT(*) FROM tbl").as(scalar[BigInt].single)

implicit val columnToBigInteger: Column[BigInteger]

Column conversion to Java big integer.

import anorm.SqlParser.scalar
import anorm.Column.columnToScalaBigInteger

val c: BigInteger =
  SQL("SELECT COUNT(*) FROM tbl").as(scalar[BigInteger].single)

implicit val columnToBoolean: Column[Boolean]

implicit val columnToByte: Column[Byte]

implicit val columnToByteArray: Column[Array[Byte]]

Column conversion to bytes array.

import anorm.SqlParser.scalar
import anorm.Column.columnToByteArray

val bytes: Array[Byte] = SQL("SELECT bin FROM tbl").
  as(scalar[Array[Byte]].single)

implicit val columnToChar: Column[Char]

Column conversion to character.

import anorm.SqlParser.scalar
import anorm.Column.columnToChar

val c: Char = SQL("SELECT char FROM tbl").as(scalar[Char].single)

implicit val columnToDate: Column[Date]

Parses column as Java Date.

import java.util.Date

val d: Date = SQL("SELECT last_mod FROM tbl").as(scalar[Date].single)

implicit val columnToDouble: Column[Double]

implicit val columnToFloat: Column[Float]

implicit val columnToInputStream: Column[InputStream]

Column conversion to bytes array.

import anorm.SqlParser.scalar
import anorm.Column.columnToInputStream

val bytes: InputStream = SQL("SELECT bin FROM tbl").
  as(scalar[InputStream].single)

implicit val columnToInstant: Column[Instant]

Parses column as Java8 instant.

import java.time.Instant
import anorm.Java8._

val i: Instant = SQL("SELECT last_mod FROM tbl").as(scalar[Instant].single)

implicit val columnToInt: Column[Int]

implicit val columnToJavaBigDecimal: Column[BigDecimal]

Column conversion to Java big decimal.

import java.math.{ BigDecimal => JBigDecimal }
import anorm.SqlParser.scalar
import anorm.Column.columnToJavaBigDecimal

val c: JBigDecimal =
  SQL("SELECT COUNT(*) FROM tbl").as(scalar[JBigDecimal].single)

implicit val columnToJodaDateTime: Column[DateTime]

Parses column as joda DateTime

import org.joda.time.DateTime

val d: Date = SQL("SELECT last_mod FROM tbl").as(scalar[DateTime].single)

implicit val columnToJodaInstant: Column[Instant]

Parses column as joda Instant

import org.joda.time.Instant

val d: Date = SQL("SELECT last_mod FROM tbl").as(scalar[Instant].single)

implicit val columnToJodaLocalDate: Column[LocalDate]

Parses column as Joda local date.

import org.joda.time.LocalDate

val i: LocalDate = SQL("SELECT last_mod FROM tbl").
  as(scalar[LocalDate].single)

implicit val columnToJodaLocalDateTime: Column[LocalDateTime]

Parses column as Joda local date/time.

import org.joda.time.LocalDateTime

val i: LocalDateTime = SQL("SELECT last_mod FROM tbl").
  as(scalar[LocalDateTime].single)

implicit def columnToList[T](implicit transformer: Column[T], t: ClassTag[T]): Column[List[T]]

Parses column as list.

implicit val columnToLocalDate: Column[LocalDate]

Parses column as Java8 local date.

import java.time.LocalDateTime
import anorm.Java8._

val i: LocalDateTime = SQL("SELECT last_mod FROM tbl").
  as(scalar[LocalDateTime].single)

implicit val columnToLocalDateTime: Column[LocalDateTime]

Parses column as Java8 local date/time.

import java.time.LocalDateTime
import anorm.Java8._

val i: LocalDateTime = SQL("SELECT last_mod FROM tbl").
  as(scalar[LocalDateTime].single)

implicit val columnToLong: Column[Long]

implicit def columnToOption[T](implicit transformer: Column[T]): Column[Option[T]]

implicit val columnToScalaBigDecimal: Column[BigDecimal]

Column conversion to big decimal.

import anorm.SqlParser.scalar
import anorm.Column.columnToScalaBigDecimal

val c: BigDecimal =
  SQL("SELECT COUNT(*) FROM tbl").as(scalar[BigDecimal].single)

implicit val columnToShort: Column[Short]

implicit val columnToString: Column[String]

implicit val columnToUUID: Column[UUID]

implicit val columnToZonedDateTime: Column[ZonedDateTime]

Parses column as Java8 zoned date/time.

import java.time.ZonedDateTime
import anorm.Java8._

val i: ZonedDateTime = SQL("SELECT last_mod FROM tbl").
  as(scalar[ZonedDateTime].single)

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

def nonNull[A](transformer: (Any, MetaDataItem) ⇒ Either[SqlRequestError, A]): Column[A]

Helper function to implement column conversion.

final def notify(): Unit

final def notifyAll(): Unit

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 nonNull1[A](transformer: (Any, MetaDataItem) ⇒ Either[SqlRequestError, A]): Column[A]