SimpleSql

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

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

Converts this query 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 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

def fold[T](z: ⇒ T)(op: (T, Row) ⇒ T)(implicit connection: Connection): Either[List[Throwable], T]

Aggregates over all rows using the specified operator.

def foldWhile[T](z: ⇒ T)(op: (T, Row) ⇒ (T, Boolean))(implicit connection: Connection): Either[List[Throwable], T]

Aggregates over part of or the while row stream, using the specified operator.

final def getClass(): Class[_]

final def isInstanceOf[T0]: Boolean

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 preparedStatement(connection: Connection, getGeneratedKeys: Boolean = false): ManagedResource[PreparedStatement]

def resultSet(connection: Connection): ManagedResource[ResultSet]

Executes this statement as query (see executeQuery) and returns result.

val resultSetOnFirstRow: Boolean

ResultSet is initialized on first row (JDBC degraded)

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]

Returns a copy with updated timeout.

def withResult[T](op: (Option[Cursor]) ⇒ T)(implicit connection: Connection): Either[List[Throwable], T]

Processes all or some rows from current result.

def withResultSetOnFirstRow(onFirst: Boolean): SimpleSql[T]

Returns a copy with updated flag.

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

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

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

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

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

Applies current parser with optionnal list of rows (0..n).

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

Applies current parser to exactly on row.

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

Applies current parser to one optional row.