Delete

abstract def cqlFor(q: Q): String

function that writes query Q to their CQL representations *

abstract def cqlStatement: String

raw cql statement *

abstract def fill(i: Q, s: PreparedStatement, protocolVersion: ProtocolVersion): BoundStatement

fills prepared statement with any I to form bound statement *

abstract def read(r: Row, protocolVersion: ProtocolVersion): Either[Throwable, R]

function that read values from the row with converting them to R or presenting read failure *

abstract def read(r: ResultSet, protocolVersion: ProtocolVersion): Either[Throwable, R]

reads the result received from executing the statement *

abstract def readBatchResult(i: Q): BatchResultReader[R]

for batch results, this allows to read result realted to this batched statement *

abstract def writeRaw(q: Q, protocolVersion: ProtocolVersion): Map[String, ByteBuffer]

function that writes query Q to their raw values *

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

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

final def ==(arg0: Any): Boolean

def as[A](implicit G: Aux[A, R]): Delete[Q, A]

retruns result as class A given it can be constructed from R *

def asA[A](implicit V: Aux[R, ::[A, HNil]]): Delete[Q, A]

retruns result as A given there is only single result *

def asHlist(implicit V: Values[R]): Delete[Q, Out]

returns result as Hlist, stripping any key types *

final def asInstanceOf[T0]: T0

def asTuple(implicit T: Tupler[R]): Delete[Q, shapeless.ops.hlist.Tupler.Out]

returns result as tuple *

def clone(): AnyRef

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

def ensuring(cond: (Delete[Q, R]) ⇒ Boolean): Delete[Q, R]

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

def ensuring(cond: Boolean): Delete[Q, R]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def formatted(fmtstr: String): String

def from[A](implicit G: Aux[A, Q]): Delete[A, R]

transforms update to read from given class A *

def fromA[A](implicit V: Aux[Q, ::[A, HNil]]): Delete[A, R]

def fromHList[L <: HList](implicit V: Aux[Q, L]): Delete[L, R]

reads from given supplied HList.

def fromTuple[T](implicit T: Aux[T, Q]): Delete[T, R]

reads delete from supplied tuple.

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def map[R2](f: (R) ⇒ R2): Delete[Q, R2]

def mapIn[Q2](f: (Q2) ⇒ Q): Delete[Q2, R]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

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): (Delete[Q, R], B)

val self: Delete[Q, R]

val self: Delete[Q, R]