ToStatement

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

implicit def arrayToParameter[A <: AnyRef](implicit m: ParameterMetaData[A]): ToStatement[Array[A]] with NotNullGuard

Sets an array parameter on statement.

final def asInstanceOf[T0]: T0

implicit def binaryStreamToStatement[S <: InputStream]: ToStatement[S]

Sets a binary stream as parameter on statement.

SQL("INSERT INTO Table(bin) VALUES {b}").on("b" -> inputStream)

implicit def blobToStatement[B <: Blob]: ToStatement[B]

Sets a blob as parameter on statement.

val blob = con.createBlob()
blob.setBytes(1, byteArray)
SQL("INSERT INTO Table(bin) VALUES {b}").on("b" -> blob)

implicit object booleanToStatement extends ToStatement[Boolean]

Sets boolean value on statement.

SQL("SELECT * FROM Test WHERE enabled = {b}").on('b -> true)

implicit object byteArrayToStatement extends ToStatement[Array[Byte]]

Sets an array of byte as parameter on statement.

SQL("INSERT INTO Table(bin) VALUES {b}").on("b" -> arrayOfBytes)

implicit object byteToStatement extends ToStatement[Byte]

Sets byte value on statement.

SQL("SELECT * FROM Test WHERE flag = {b}").on('b -> 1.toByte)

implicit object charToStatement extends ToStatement[Char]

Sets character as parameter value.

SQL("SELECT * FROM tbl WHERE flag = {c}").on("c" -> 'f')

implicit def characterStreamToStatement[R <: Reader]: ToStatement[R]

Sets a character stream as parameter on statement.

SQL("INSERT INTO Table(chars) VALUES {c}").on("c" -> reader)

implicit object characterToStatement extends ToStatement[Character]

Sets Java Character as parameter value.

SQL("SELECT * FROM tbl WHERE flag = {c}").
  on("c" -> new java.lang.Character('f'))

def clone(): AnyRef

implicit object dateToStatement extends ToStatement[Date]

Sets date as statement parameter.

SQL("UPDATE tbl SET modified = {d}").on('d -> new Date())

implicit object doubleToStatement extends ToStatement[Double]

Sets double value on statement.

SQL("SELECT * FROM Test WHERE flag = {b}").on('b -> 1d)

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

implicit object floatToStatement extends ToStatement[Float]

Sets float value on statement.

SQL("SELECT * FROM Test WHERE flag = {b}").on('b -> 1f)

final def getClass(): Class[_]

def hashCode(): Int

implicit def idToStatement[A](implicit c: ToStatement[A]): ToStatement[Id[A]] with NotNullGuard

Sets Id parameter on statement.

SQL("INSERT INTO tbl(id, name) VALUES ({i}, {v}").
  on("i" -> anorm.Id("id"), "v" -> "name")

implicit def instantToStatement(implicit meta: ParameterMetaData[Instant]): ToStatement[Instant]

Sets a temporal instant on statement.

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

SQL("SELECT * FROM Test WHERE time < {b}").on('b -> Instant.now)

implicit object intToStatement extends ToStatement[Int]

Sets integer value on statement.

SQL("SELECT * FROM Test WHERE flag = {b}").on('b -> 1)

implicit object integerToStatement extends ToStatement[Integer]

Sets Java Integer object on statement.

SQL("SELECT * FROM Test WHERE flag = {b}").
  on('b -> new java.lang.Integer(1))

final def isInstanceOf[T0]: Boolean

implicit object javaBigDecimalToStatement extends ToStatement[BigDecimal]

Sets Java big decimal on statement.

SQL("UPDATE tbl SET max = {m}").on('m -> new java.math.BigDecimal(10.02f))

implicit object javaBigIntegerToStatement extends ToStatement[BigInteger]

Sets Java big integer on statement.

SQL("UPDATE tbl SET max = {m}").on('m -> new BigInteger(15))

implicit object javaBooleanToStatement extends ToStatement[Boolean]

Sets Java Boolean object on statement.

SQL("SELECT * FROM Test WHERE enabled = {b}").
  on('b -> java.lang.Boolean.TRUE)

implicit object javaByteToStatement extends ToStatement[Byte]

Sets Java Byte object on statement.

SQL("SELECT * FROM Test WHERE flag = {b}").on('b -> new java.lang.Byte(1))

implicit object javaDoubleToStatement extends ToStatement[Double]

Sets Java Double object on statement.

SQL("SELECT * FROM Test WHERE flag = {b}").
  on('b -> new java.lang.Double(1d))

implicit object javaFloatToStatement extends ToStatement[Float]

Sets Java Float object on statement.

SQL("SELECT * FROM Test WHERE flag = {b}").
  on('b -> new java.lang.Float(1f))

implicit object javaLongToStatement extends ToStatement[Long]

Sets Java Long object on statement.

SQL("SELECT * FROM Test WHERE flag = {b}").
  on('b -> new java.lang.Long(1l))

implicit object javaShortToStatement extends ToStatement[Short]

Sets Java Short object on statement.

SQL("SELECT * FROM Test WHERE flag = {b}").
  on('b -> new java.lang.Short(1.toShort))

implicit def jodaDateTimeToStatement(implicit meta: ParameterMetaData[DateTime]): ToStatement[DateTime]

Sets joda-time DateTime as statement parameter.

import org.joda.time.DateTime

SQL("UPDATE tbl SET modified = {d}").on('d -> new DateTime())

implicit def jodaInstantToStatement(implicit meta: ParameterMetaData[Instant]): ToStatement[Instant]

Sets joda-time Instant as statement parameter.

import org.joda.time.Instant

SQL("UPDATE tbl SET modified = {d}").on('d -> new Instant())

implicit def listToStatement[A](implicit c: ToStatement[A]): ToStatement[List[A]]

Sets multi-value parameter from list on statement.

SQL("SELECT * FROM Test WHERE cat IN ({categories})").
  on('categories -> List(1, 3, 4)

implicit def localDateTimeToStatement(implicit meta: ParameterMetaData[LocalDateTime]): ToStatement[LocalDateTime]

Sets a local date/time on statement.

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

SQL("SELECT * FROM Test WHERE time < {b}").on('b -> LocalDateTime.now)

implicit object longToStatement extends ToStatement[Long]

Sets long value on statement.

SQL("SELECT * FROM Test WHERE flag = {b}").on('b -> 1l)

final def ne(arg0: AnyRef): Boolean

implicit object notAssignedToStatement extends ToStatement[NotAssigned.type]

Sets null for not assigned value.

SQL("SELECT * FROM Test WHERE category = {c}").on('c -> NotAssigned)

final def notify(): Unit

final def notifyAll(): Unit

implicit object objectToStatement extends ToStatement[Object]

Sets opaque value as statement parameter.

SQL("EXEC indexed_at {d}").on('d -> anorm.Object(new java.util.Date()))

implicit def optionToStatement[A](implicit c: ToStatement[A], meta: ParameterMetaData[A]): ToStatement[Option[A]] with NotNullGuard

Sets optional A inferred as Option[A].

SQL("SELECT * FROM Test WHERE category = {c}").on('c -> Option("cat"))
SQL"SELECT * FROM Test WHERE nullable_int = \${Option.empty[Int]}"

implicit object scalaBigDecimalToStatement extends ToStatement[BigDecimal]

Sets big decimal on statement.

SQL("UPDATE tbl SET max = {m}").on('m -> BigDecimal(10.02f))

implicit object scalaBigIntegerToStatement extends ToStatement[BigInt]

Sets big integer on statement.

SQL("UPDATE tbl SET max = {m}").on('m -> BigInt(15))

implicit def seqParamToStatement[A](implicit c: ToStatement[Seq[A]]): ToStatement[SeqParameter[A]] with NotNullGuard

Sets multi-value parameter on statement, with custom formatting (using anorm.SeqParameter).

import anorm.SeqParameter
SQL("SELECT * FROM Test t WHERE {categories}").
  on('categories -> SeqParameter(
    values = Seq("a", "b", "c"), separator = " OR ",
    pre = "EXISTS (SELECT NULL FROM j WHERE t.id=j.id AND name=",
    post = ")"))

implicit def seqToStatement[A](implicit c: ToStatement[A]): ToStatement[Seq[A]]

Sets multi-value parameter from sequence on statement.

SQL("SELECT * FROM Test WHERE cat IN ({categories})").
  on('categories -> Seq("a", "b", "c")

implicit def setToStatement[A](implicit c: ToStatement[A]): ToStatement[Set[A]]

Sets multi-value parameter from set on statement.

SQL("SELECT * FROM Test WHERE cat IN ({categories})").
  on('categories -> Set(1, 3, 4)

implicit object shortToStatement extends ToStatement[Short]

Sets short value on statement.

SQL("SELECT * FROM Test WHERE flag = {b}").on('b -> 1.toShort)

implicit def someToStatement[A](implicit c: ToStatement[A]): ToStatement[Some[A]] with NotNullGuard

Sets not empty optional A inferred as Some[A].

SQL("SELECT * FROM Test WHERE category = {c}").on('c -> Some("cat"))

implicit def sortedSetToStatement[A](implicit c: ToStatement[A]): ToStatement[SortedSet[A]]

Sets multi-value parameter from sorted set on statement.

SQL("SELECT * FROM Test WHERE cat IN ({categories})").
  on('categories -> SortedSet("a", "b", "c")

implicit def streamToStatement[A](implicit c: ToStatement[A]): ToStatement[Stream[A]]

Sets multi-value parameter from stream on statement.

SQL("SELECT * FROM Test WHERE cat IN ({categories})").
  on('categories -> Stream(1, 3, 4)

implicit object stringToStatement extends ToStatement[String]

Sets string as parameter value.

SQL("SELECT * FROM tbl WHERE name = {n}").on("n" -> "str")

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

implicit object timestampToStatement extends ToStatement[Timestamp]

Sets timestamp as statement parameter.

SQL("UPDATE tbl SET modified = {ts}").
  on('ts -> new Timestamp(date.getTime))

implicit def timestampWrapper1ToStatement[T <: TimestampWrapper1]: ToStatement[T]

Sets a wrapped timestamp as statement parameter.

val wrapper = new {
  // Any value with a `.getTimestamp`
  val getTimestamp = new java.sql.Timestamp(123L)
}

SQL("UPDATE tbl SET modified = {ts}").on('ts -> wrapper)

def toString(): String

implicit object uuidToStatement extends ToStatement[UUID]

Sets UUID as statement parameter.

SQL("INSERT INTO lang_tbl(id, name) VALUE ({i}, {n})").
  on("i" -> JUUID.randomUUID(), "n" -> "lang")

implicit def vectorToStatement[A](implicit c: ToStatement[A]): ToStatement[Vector[A]]

Sets multi-value parameter from vector on statement.

SQL("SELECT * FROM Test WHERE cat IN ({categories})").
  on('categories -> Vector("a", "b", "c")

final def wait(): Unit

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

final def wait(arg0: Long): Unit

implicit def zonedDateTimeToStatement(implicit meta: ParameterMetaData[ZonedDateTime]): ToStatement[ZonedDateTime]

Sets a zoned date/time on statement.

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

SQL("SELECT * FROM Test WHERE time < {b}").on('b -> ZonedDateTime.now)

implicit object noneToStatement extends ToStatement[None.type]

Sets null for None value.

SQL("SELECT * FROM Test WHERE category = {c}")
  .on('c -> None)