SimpleSql

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def apply()(implicit connection: Connection): Stream[Row]

Executes this SQL statement as query, returns result as Row stream.

def as[T](parser: ResultSetParser[T])(implicit connection: Connection): T

Executes this statement as query and convert result as T, using parser.

final def asInstanceOf[T0]: T0

def clone(): AnyRef

val defaultParser: RowParser[T]

final def eq(arg0: AnyRef): Boolean

def execute()(implicit connection: Connection): Boolean

Executes this SQL statement.

def execute1(getGeneratedKeys: Boolean = false)(implicit connection: Connection): (PreparedStatement, Int)

def executeInsert[A](generatedKeysParser: ResultSetParser[A] = SqlParser.scalar[Long].singleOpt)(implicit connection: Connection): A

Executes this SQL as an insert statement.

def executeQuery()(implicit connection: Connection): SqlQueryResult

Executes this SQL query, and returns its result.

implicit val conn: Connection = openConnection
val res: SqlQueryResult =
  SQL("SELECT text_col FROM table WHERE id = {code}").
  on("code" -> code).executeQuery()
// Check execution context; e.g. res.statementWarning
val str = res as scalar[String].single // going with row parsing

def executeUpdate()(implicit connection: Connection): Int

Executes this SQL as an update statement.

def finalize(): Unit

final def getClass(): Class[_]

def getFilledStatement(connection: Connection, getGeneratedKeys: Boolean = false): PreparedStatement

final def isInstanceOf[T0]: Boolean

def list()(implicit connection: Connection): Seq[T]

def map[A](f: (T) ⇒ A): SimpleSql[A]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def on(args: NamedParameter*): SimpleSql[T]

Returns query prepared with named parameters.

import anorm.toParameterValue

val baseSql = SQL("SELECT * FROM table WHERE id = {id}") // one named param
val preparedSql = baseSql.withParams("id" -> "value")

def onParams(args: ParameterValue*): SimpleSql[T]

Returns query prepared with parameters using initial order of placeholder in statement.

import anorm.toParameterValue

val baseSql =
  SQL("SELECT * FROM table WHERE name = {name} AND lang = {lang}")

val preparedSql = baseSql.onParams("1st", "2nd")
// 1st param = name, 2nd param = lang

val params: Map[String, ParameterValue]

def single()(implicit connection: Connection): T

def singleOpt()(implicit connection: Connection): Option[T]

val sql: SqlQuery

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

def using[U](p: RowParser[U]): SimpleSql[U]

Prepares query with given row parser.

import anorm.{ SQL, SqlParser }

val res: Int = SQL("SELECT 1").using(SqlParser.scalar[Int]).single
// Equivalent to: SQL("SELECT 1").as(SqlParser.scalar[Int].single)

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withQueryTimeout(seconds: Option[Int]): SimpleSql[T]

def filledStatement(implicit connection: Connection): PreparedStatement

def list[A](rowParser: RowParser[A])(implicit connection: Connection): Seq[A]

def parse[T](parser: ResultSetParser[T])(implicit connection: Connection): T

def single[T](rowParser: RowParser[T])(implicit connection: Connection): T

def singleOpt[T](rowParser: RowParser[T])(implicit connection: Connection): Option[T]