MutatingStatementInvoker

abstract def extractValue(pr: PositionedResult): R

abstract def getStatement: String

abstract def setParam(param: P, st: PreparedStatement): Unit

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

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

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

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def andThen[A](g: (UnitInvoker[R]) ⇒ A): (P) ⇒ A

def apply(parameter: P): MutatingUnitInvoker[R]

Apply the parameter for this Invoker, creating a parameterless UnitInvoker.

final def asInstanceOf[T0]: T0

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

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

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

Execute the statement and return a fully materialized collection.

def clone(): AnyRef

def compose[A](g: (A) ⇒ P): (A) ⇒ UnitInvoker[R]

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

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

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

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

final def enumerate[B, RR >: R](param: P, 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.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

final def execute(param: P)(implicit session: SessionDef): Unit

Execute the statement and ignore the results.

def finalize(): Unit

final def first(param: P)(implicit session: SessionDef): R

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

def firstFlatten[B](param: P)(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 firstOption(param: P)(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 foldLeft[B](param: P, 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 foreach(param: P, f: (R) ⇒ Unit, maxRows: Int)(implicit session: SessionDef): Unit

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

final def foreach(param: P, f: (R) ⇒ Unit)(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(param: P)(implicit session: SessionDef): CloseableIterator[R]

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

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

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

final def list(param: P)(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[P, U]

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

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

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

final def mutate(param: P)(f: (ResultSetMutator[R]) ⇒ Unit)(implicit session: SessionDef): Unit

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

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(param: P, maxRows: Int, defaultType: ResultSetType = ResultSetType.ForwardOnly, defaultConcurrency: ResultSetConcurrency = ResultSetConcurrency.ReadOnly, defaultHoldability: ResultSetHoldability = ResultSetHoldability.Default)(implicit session: SessionDef): Either[Int, PositionedResultIterator[R]]

Invoke the statement and return the raw results.

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

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

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[P, R], B)

val self: Any

val self: Any

final def elements(param: P)(implicit session: SessionDef): CloseableIterator[R]

def elementsTo(param: P, maxRows: Int)(implicit session: SessionDef): CloseableIterator[R]

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

def x: MutatingStatementInvoker[P, R]

def x: MutatingStatementInvoker[P, R]