ToStatementPriority0

sealed trait ToStatementPriority0 extends AnyRef

Linear Supertypes

AnyRef, Any

Known Subclasses

ToStatementPriority1

Ordering

Alphabetic
By Inheritance

Inherited

ToStatementPriority0
AnyRef
Any

Hide All
Show All

Visibility

Public
All

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
implicit def arrayToParameter[A <: AnyRef](implicit m: ParameterMetaData[A]): ToStatement[Array[A]]
Sets an array parameter on statement (see java.sql.Array).
Sets an array parameter on statement (see java.sql.Array).
```
import anorm._

SQL("INSERT INTO Table(arr) VALUES {a}").
  on("a" -> Array("A", "2", "C"))
```
final def asInstanceOf[T0]: T0

Definition Classes
Any
implicit def binaryStreamToStatement[S <: InputStream]: ToStatement[S]
Sets a binary stream as parameter on statement.
Sets a binary stream as parameter on statement. For null value, setNull with LONGVARBINARY is called on statement.
```
// skip-doc-5f98a5e
import anorm._

def foo(inputStream: java.io.InputStream) =
  SQL("INSERT INTO Table(bin) VALUES {b}").on("b" -> inputStream)
```

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

Sets a blob as parameter on statement.

Sets a blob as parameter on statement. For null value, setNull with BLOB is called on statement.

// skip-doc-5f98a5e
import anorm._

def foo(byteArray: Array[Byte])(implicit con: java.sql.Connection) = {
  val blob = con.createBlob()
  blob.setBytes(1, byteArray)

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

implicit def characterStreamToStatement[R <: Reader]: ToStatement[R]
Sets a character stream as parameter on statement.
Sets a character stream as parameter on statement. For null value, setNull with VARCHAR is called on statement.
```
// skip-doc-5f98a5e
import anorm._

def foo(reader: java.io.Reader) =
  SQL("INSERT INTO Table(chars) VALUES {c}").on("c" -> reader)
```
def clone(): AnyRef

Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws( ... ) @native()
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
Annotations
@native()
def hashCode(): Int

Definition Classes
AnyRef → Any
Annotations
@native()
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
implicit def listToStatement[A](implicit c: ToStatement[A]): ToStatement[List[A]]
Sets multi-value parameter from list on statement.
Sets multi-value parameter from list on statement.
```
import anorm._

SQL("SELECT * FROM Test WHERE cat IN ({categories})").
  on("categories" -> List(1, 3, 4))
```
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
Annotations
@native()
final def notifyAll(): Unit

Definition Classes
AnyRef
Annotations
@native()
implicit def optionToStatement[A](implicit c: ToStatement[A], meta: ParameterMetaData[A]): ToStatement[Option[A]]
Sets optional A inferred as Option[A].
Sets optional A inferred as Option[A].
```
import anorm._

SQL("SELECT * FROM Test WHERE category = {c}").on("c" -> Option("cat"))
SQL"SELECT * FROM Test WHERE nullable_int = \${Option.empty[Int]}"
```
implicit def seqParamToStatement[A](implicit c: ToStatement[Seq[A]]): ToStatement[SeqParameter[A]]
Sets multi-value parameter on statement, with custom formatting (using SeqParameter).
Sets multi-value parameter on statement, with custom formatting (using SeqParameter).
```
import anorm._

SQL("SELECT * FROM Test t WHERE {categories}").
  on("categories" -> SeqParameter(
    seq = Seq("a", "b", "c"), sep = " 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.
Sets multi-value parameter from sequence on statement.
```
import anorm._

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.
Sets multi-value parameter from set on statement.
```
import anorm._

SQL("SELECT * FROM Test WHERE cat IN ({categories})").
  on("categories" -> Set(1, 3, 4))
```
implicit def someToStatement[A](implicit c: ToStatement[A]): ToStatement[Some[A]]
Sets not empty optional A inferred as Some[A].
Sets not empty optional A inferred as Some[A].
```
import anorm._

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.
Sets multi-value parameter from sorted set on statement.
```
import scala.collection.immutable.SortedSet

import anorm._

SQL("SELECT * FROM Test WHERE cat IN ({categories})").
  on("categories" -> SortedSet("a", "b", "c"))
```
implicit def streamToStatement[A](implicit c: ToStatement[A]): ToStatement[LazyLst[A]]
Sets multi-value parameter from stream on statement.
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
implicit def timestampWrapper1ToStatement[T <: TimestampWrapper1]: ToStatement[T]
Sets a wrapped timestamp as statement parameter.
Sets a wrapped timestamp as statement parameter. For null value, setNull with TIMESTAMP is called on statement.
```
// skip-doc-5f98a5e
import anorm._

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

Definition Classes
AnyRef → Any
implicit def vectorToStatement[A](implicit c: ToStatement[A]): ToStatement[Vector[A]]
Sets multi-value parameter from vector on statement.
Sets multi-value parameter from vector on statement.
```
import anorm._

SQL("SELECT * FROM Test WHERE cat IN ({categories})").
  on("categories" -> Vector("a", "b", "c"))
```
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... ) @native()
implicit object booleanToStatement extends ToStatement[Boolean]
Sets boolean value on statement.
Sets boolean value on statement.
```
import anorm._

SQL("SELECT * FROM Test WHERE enabled = {b}").on("b" -> true)
```
implicit object byteToStatement extends ToStatement[Byte]
Sets byte value on statement.
Sets byte value on statement.
```
import anorm._

SQL("SELECT * FROM Test WHERE flag = {b}").on("b" -> 1.toByte)
```
implicit object charToStatement extends ToStatement[Char]
Sets character as parameter value.
Sets character as parameter value.
```
import anorm._

SQL("SELECT * FROM tbl WHERE flag = {c}").on("c" -> 'f')
```
implicit object characterToStatement extends ToStatement[Character]
Sets Java Character as parameter value.
Sets Java Character as parameter value. For null character, setNull with VARCHAR is called on statement.
```
import anorm._

SQL("SELECT * FROM tbl WHERE flag = {c}").
  on("c" -> new java.lang.Character('f'))
```
implicit object dateToStatement extends ToStatement[Date]
Sets date as statement parameter.
Sets date as statement parameter. For null value, setNull with TIMESTAMP is called on statement.
```
import anorm._

SQL("UPDATE tbl SET modified = {d}").on("d" -> new java.util.Date())
```
implicit object doubleToStatement extends ToStatement[Double]
Sets double value on statement.
Sets double value on statement.
```
import anorm._

SQL("SELECT * FROM Test WHERE flag = {b}").on("b" -> 1D)
```
implicit object floatToStatement extends ToStatement[Float]
Sets float value on statement.
Sets float value on statement.
```
import anorm._

SQL("SELECT * FROM Test WHERE flag = {b}").on("b" -> 1F)
```
implicit object intToStatement extends ToStatement[Int]
Sets integer value on statement.
Sets integer value on statement.
```
import anorm._

SQL("SELECT * FROM Test WHERE flag = {b}").on("b" -> 1)
```
implicit object integerToStatement extends ToStatement[Integer]
Sets Java Integer object on statement.
Sets Java Integer object on statement. For null value, setNull with INTEGER is called on statement.
```
import anorm._

SQL("SELECT * FROM Test WHERE flag = {b}").
  on("b" -> new java.lang.Integer(1))
```
implicit object javaBigDecimalToStatement extends ToStatement[BigDecimal]
Sets Java big decimal on statement.
Sets Java big decimal on statement. Value null is accepted.
```
import anorm._

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.
Sets Java big integer on statement. For null value, setNull with NUMERIC is called on statement.
```
import anorm._

SQL("UPDATE tbl SET max = {m}").
  on("m" -> new java.math.BigInteger("15"))
```
implicit object javaBooleanToStatement extends ToStatement[Boolean]
Sets Java Boolean object on statement.
Sets Java Boolean object on statement. For null value, setNull with BOOLEAN is called on statement.
```
import anorm._

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.
Sets Java Byte object on statement. For null value, setNull with TINYINT is called on statement.
```
import anorm._

SQL("SELECT * FROM Test WHERE flag = {b}").
  on("b" -> new java.lang.Byte(1: Byte))
```
implicit object javaDoubleToStatement extends ToStatement[Double]
Sets Java Double object on statement.
Sets Java Double object on statement. For null value, setNull with DOUBLE is called on statement.
```
import anorm._

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.
Sets Java Float object on statement. For null value, setNull with FLOAT is called on statement.
```
import anorm._

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.
Sets Java Long object on statement. For null value, setNull with BIGINT is called on statement.
```
import anorm._

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.
Sets Java Short object on statement. For null value, setNull with SMALLINT is called on statement.
```
import anorm._

SQL("SELECT * FROM Test WHERE flag = {b}").
  on("b" -> new java.lang.Short(1.toShort))
```
implicit object longToStatement extends ToStatement[Long]
Sets long value on statement.
Sets long value on statement.
```
import anorm._

SQL("SELECT * FROM Test WHERE flag = {b}").on("b" -> 1L)
```
implicit object objectToStatement extends ToStatement[Object]
Sets opaque value as statement parameter.
Sets opaque value as statement parameter. UNSAFE: It's set using java.sql.PreparedStatement.setObject.
```
import anorm._

SQL("EXEC indexed_at {d}").
  on("d" -> anorm.Object(new java.util.Date()))
```
implicit object scalaBigDecimalToStatement extends ToStatement[BigDecimal]
Sets big decimal on statement.
Sets big decimal on statement. For null value, setNull with DECIMAL is called on statement.
```
import anorm._

SQL("UPDATE tbl SET max = {m}").on("m" -> BigDecimal(10.02F))
```
implicit object scalaBigIntegerToStatement extends ToStatement[BigInt]
Sets big integer on statement.
Sets big integer on statement. For null value, setNull with NUMERIC is called on statement.
```
import anorm._

SQL("UPDATE tbl SET max = {m}").on("m" -> BigInt(15))
```
implicit object shortToStatement extends ToStatement[Short]
Sets short value on statement.
Sets short value on statement.
```
import anorm._

SQL("SELECT * FROM Test WHERE flag = {b}").on("b" -> 1.toShort)
```
implicit object stringToStatement extends ToStatement[String]
Sets string as parameter value.
Sets string as parameter value. Value null is accepted.
```
import anorm._

SQL("SELECT * FROM tbl WHERE name = {n}").on("n" -> "str")
```
implicit object timestampToStatement extends ToStatement[Timestamp]
Sets timestamp as statement parameter.
Sets timestamp as statement parameter. Value null is accepted.
```
import anorm._

def foo(date: java.util.Date) =
  SQL("UPDATE tbl SET modified = {ts}").
    on("ts" -> new java.sql.Timestamp(date.getTime))
```
implicit object uriToStatement extends ToStatement[URI]
Sets URI as statement parameter.
Sets URI as statement parameter. For null value, setNull with VARCHAR is called on statement.
```
import anorm._

SQL("INSERT INTO lang_tbl(id, name) VALUE ({i}, {n})").
  on("i" -> new java.net.URI("https://github.com/playframework/"),
     "n" -> "lang")
```
implicit object urlToStatement extends ToStatement[URL]
Sets URL as statement parameter.
Sets URL as statement parameter. For null value, setNull with VARCHAR is called on statement.
```
import anorm._

SQL("INSERT INTO lang_tbl(id, name) VALUE ({i}, {n})").
  on("i" -> new java.net.URL("https://github.com/playframework/"),
     "n" -> "lang")
```
implicit object uuidToStatement extends ToStatement[UUID]
Sets UUID as statement parameter.
Sets UUID as statement parameter. For null value, setNull with VARCHAR is called on statement.
```
import anorm._

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

Deprecated Value Members

implicit object noneToStatement extends ToStatement[None.type]
Sets null for None value.
Sets null for None value.
```
import anorm._

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

// Rather use:
anorm.SQL("SELECT * FROM Test WHERE category = {c}").
  on("c" -> Option.empty[String]) // Not deprecated
```
Annotations
@deprecated
Deprecated
(Since version 2.3.7) Parameter value should be passed using Option.empty[T]

Packages

ToStatementPriority0

sealed trait ToStatementPriority0 extends AnyRef

Value Members

Deprecated Value Members

Inherited from AnyRef

Inherited from Any

Ungrouped

Packages

ToStatementPriority0 

sealed trait ToStatementPriority0 extends AnyRef

Value Members

Deprecated Value Members

Inherited from AnyRef

Inherited from Any

Ungrouped

ToStatementPriority0