MutatingStatementInvoker

abstract def extractValue(pr: PositionedResult): R

abstract def getStatement: String

abstract def setParam(st: PreparedStatement): Unit

abstract def updateRowValues(rs: PositionedResult, value: R): Unit

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

def ->[B](y: B): (MutatingStatementInvoker[R], B)

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

final def buildColl[C[_]](implicit session: SessionDef, canBuildFrom: CanBuildFrom[Nothing, R, C[R]]): C[R]

Execute the statement and return a fully materialized collection.

def clone(): AnyRef

def ensuring(cond: (MutatingStatementInvoker[R]) ⇒ Boolean, msg: ⇒ Any): MutatingStatementInvoker[R]

def ensuring(cond: (MutatingStatementInvoker[R]) ⇒ Boolean): MutatingStatementInvoker[R]

def ensuring(cond: Boolean, msg: ⇒ Any): MutatingStatementInvoker[R]

def ensuring(cond: Boolean): MutatingStatementInvoker[R]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

final def execute(implicit session: SessionDef): Unit

Execute the statement and ignore the results.

def finalize(): Unit

final def first(implicit session: SessionDef): R

Execute the statement and return the first row of the result set.

final def firstOption(implicit session: SessionDef): Option[R]

Execute the statement and return the first row of the result set wrapped in Some, or None if the result set is empty.

final def foreach(f: (R) ⇒ Unit, maxRows: Int = 0)(implicit session: SessionDef): Unit

Execute the statement and call f for each converted row of the result set.

def formatted(fmtstr: String): String

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def iterator(implicit session: SessionDef): CloseableIterator[R]

Execute the statement and return a CloseableIterator of the converted results.

def iteratorTo(maxRows: Int)(implicit session: SessionDef): CloseableIterator[R]

Execute the statement and return a CloseableIterator of the converted results.

val mutateConcurrency: ResultSetConcurrency

val mutateType: ResultSetType

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

val previousAfterDelete: Boolean

def results(maxRows: Int, defaultType: ResultSetType = ResultSetType.ForwardOnly, defaultConcurrency: ResultSetConcurrency = ResultSetConcurrency.ReadOnly, defaultHoldability: ResultSetHoldability = ResultSetHoldability.Default, autoClose: Boolean = true)(implicit session: SessionDef): Either[Int, PositionedResultIterator[R]]

Invoke the statement and return the raw results.

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 →[B](y: B): (MutatingStatementInvoker[R], B)

final def build[To](implicit session: SessionDef, canBuildFrom: CanBuildFrom[Nothing, R, To]): To

Execute the statement and return a fully materialized collection of the specified type.

final def enumerate[B, RR >: R](iter: IterV[RR, B])(implicit session: SessionDef): IterV[RR, B]

Execute the statement and feed the converted rows of the result set into an iteratee.

def firstFlatten[B](implicit session: SessionDef, ev: <:<[R, Option[B]]): Option[B]

If the result type of this Invoker is of the form Option[T], execute the statement and return the first row of the result set, or None if the result set is empty.

final def foldLeft[B](z: B)(op: (B, R) ⇒ B)(implicit session: SessionDef): B

Execute the statement and left-fold the converted rows of the result set.

final def list(implicit session: SessionDef): List[R]

Execute the statement and return an immutable and fully materialized list of the results.

def mapResult[U](f: (R) ⇒ U): Invoker[U]

Create a new Invoker which applies the mapping function f to each row of the result set.

def mutate(f: (ResultSetMutator[R]) ⇒ Unit, end: (ResultSetMutator[R]) ⇒ Unit)(implicit session: SessionDef): Unit

Transform a query's results with an updatable result set.

final def toMap[T, U](implicit session: SessionDef, ev: <:<[R, (T, U)]): Map[T, U]