SelectQuery

Instance Constructors

new SelectQuery(table: Table, rowFunc: (Row) ⇒ Record, init: CQLQuery, wherePart: WherePart = WherePart.empty, orderPart: OrderPart = OrderPart.empty, limitedPart: LimitedPart = LimitedPart.empty, filteringPart: FilteringPart = FilteringPart.empty, usingPart: UsingPart = UsingPart.empty, count: Boolean = false, options: QueryOptions = QueryOptions.empty)

Type Members

type QueryType[T <: CassandraTable[T, _], R, L <: LimitBound, O <: OrderBound, S <: ConsistencyBound, C <: WhereBound, P <: HList] = SelectQuery[T, R, L, O, S, C, P]

Attributes
protected[this]
Definition Classes
SelectQuery → Query
implicit class RichSession extends SessionAugmenter

Definition Classes
SessionAugmenterImplicits

Value Members

final def !=(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def !=(arg0: Any): Boolean

Definition Classes
Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def ==(arg0: Any): Boolean

Definition Classes
Any
def allowFiltering(): SelectQuery[Table, Record, Limit, Order, Status, Chain, PS]
def and[RR, HL <: HList, Out <: HList](condition: (Table) ⇒ QueryCondition[HL])(implicit ev: =:=[Chain, Chainned], prepend: shapeless.ops.hlist.Prepend.Aux[HL, PS, Out]): QueryType[Table, Record, Limit, Order, Status, Chainned, Out]

The where method of a select query.
The where method of a select query.
condition
A where clause condition restricted by path dependant types.
ev
An evidence request guaranteeing the user cannot chain multiple where clauses on the same query.
returns

Definition Classes
SelectQuery → Query
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def consistencyLevel_=(level: ConsistencyLevel)(implicit ev: =:=[Status, Unspecified], session: Session): SelectQuery[Table, Record, Limit, Order, Specified, Chain, PS]
val count: Boolean

Attributes
protected[com.outworkers.phantom]
def create[T <: CassandraTable[T, _], R, L <: LimitBound, O <: OrderBound, S <: ConsistencyBound, C <: WhereBound, P <: HList](t: T, q: CQLQuery, r: (Row) ⇒ R, part: UsingPart, opts: QueryOptions): QueryType[T, R, L, O, S, C, P]

Attributes
protected[this]
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def executableQuery: ExecutableCqlQuery

Definition Classes
SelectQuery → RootQuery
val filteringPart: FilteringPart

Attributes
protected[com.outworkers.phantom]
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def fromRow(row: Row): Record
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
val init: CQLQuery
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def limit(limit: Int)(implicit ev: =:=[Limit, Unlimited]): QueryType[Table, Record, Limited, Order, Status, Chain, PS]

Annotations
@implicitNotFound( ... )
final def limit(ps: PrepareMark)(implicit ev: =:=[Limit, Unlimited]): QueryType[Table, Record, Limited, Order, Status, Chain, ::[Int, PS]]

Annotations
@implicitNotFound( ... )
val limitedPart: LimitedPart

Attributes
protected[com.outworkers.phantom]
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
val options: QueryOptions

Definition Classes
SelectQuery → Query
final def orderBy(clauses: (Table) ⇒ Condition*)(implicit ev: =:=[Order, Unordered]): SelectQuery[Table, Record, Limit, Ordered, Status, Chain, PS]

Annotations
@implicitNotFound( ... )
val orderPart: OrderPart

Attributes
protected[com.outworkers.phantom]
def prepare[Rev <: HList]()(implicit session: Session, keySpace: KeySpace, ev: =:!=[PS, HNil], rev: Aux[PS, Rev]): PreparedSelectBlock[Table, Record, Limit, Rev]
def prepareAsync[P[_], F[_], Rev <: HList]()(implicit session: Session, executor: ExecutionContextExecutor, keySpace: KeySpace, ev: =:!=[PS, HNil], rev: Aux[PS, Rev], fMonad: Monad[F], adapter: GuavaAdapter[F], interface: PromiseInterface[P, F]): F[PreparedSelectBlock[Table, Record, Limit, Rev]]
val qb: CQLQuery

Definition Classes
SelectQuery → Query
def queryString: String

Definition Classes
RootQuery
val rowFunc: (Row) ⇒ Record

Attributes
protected[com.outworkers.phantom]
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
val table: Table

Attributes
protected[com.outworkers.phantom]
def using(clause: Condition): SelectQuery[Table, Record, Limit, Order, Status, Chainned, PS]
val usingPart: UsingPart

Attributes
protected[com.outworkers.phantom]
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
def where[RR, HL <: HList, Out <: HList](condition: (Table) ⇒ QueryCondition[HL])(implicit ev: =:=[Chain, Unchainned], prepend: shapeless.ops.hlist.Prepend.Aux[HL, PS, Out]): QueryType[Table, Record, Limit, Order, Status, Chainned, Out]

The where method of a select query.
The where method of a select query.
condition
A where clause condition restricted by path dependant types.
ev
An evidence request guaranteeing the user cannot chain multiple where clauses on the same query.
returns

Definition Classes
SelectQuery → Query
val wherePart: WherePart

Attributes
protected[com.outworkers.phantom]

Instance Constructors

Type Members

type QueryType[T <: CassandraTable[T, _], R, L <: LimitBound, O <: OrderBound, S <: ConsistencyBound, C <: WhereBound, P <: HList] = SelectQuery[T, R, L, O, S, C, P]

implicit class RichSession extends SessionAugmenter

Value Members

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def allowFiltering(): SelectQuery[Table, Record, Limit, Order, Status, Chain, PS]

def and[RR, HL <: HList, Out <: HList](condition: (Table) ⇒ QueryCondition[HL])(implicit ev: =:=[Chain, Chainned], prepend: shapeless.ops.hlist.Prepend.Aux[HL, PS, Out]): QueryType[Table, Record, Limit, Order, Status, Chainned, Out]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def consistencyLevel_=(level: ConsistencyLevel)(implicit ev: =:=[Status, Unspecified], session: Session): SelectQuery[Table, Record, Limit, Order, Specified, Chain, PS]

val count: Boolean

def create[T <: CassandraTable[T, _], R, L <: LimitBound, O <: OrderBound, S <: ConsistencyBound, C <: WhereBound, P <: HList](t: T, q: CQLQuery, r: (Row) ⇒ R, part: UsingPart, opts: QueryOptions): QueryType[T, R, L, O, S, C, P]

final def eq(arg0: AnyRef): Boolean

def executableQuery: ExecutableCqlQuery

val filteringPart: FilteringPart

def finalize(): Unit

def fromRow(row: Row): Record

final def getClass(): Class[_]

val init: CQLQuery

final def isInstanceOf[T0]: Boolean

def limit(limit: Int)(implicit ev: =:=[Limit, Unlimited]): QueryType[Table, Record, Limited, Order, Status, Chain, PS]

final def limit(ps: PrepareMark)(implicit ev: =:=[Limit, Unlimited]): QueryType[Table, Record, Limited, Order, Status, Chain, ::[Int, PS]]

val limitedPart: LimitedPart

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

val options: QueryOptions

final def orderBy(clauses: (Table) ⇒ Condition*)(implicit ev: =:=[Order, Unordered]): SelectQuery[Table, Record, Limit, Ordered, Status, Chain, PS]

val orderPart: OrderPart

def prepare[Rev <: HList]()(implicit session: Session, keySpace: KeySpace, ev: =:!=[PS, HNil], rev: Aux[PS, Rev]): PreparedSelectBlock[Table, Record, Limit, Rev]

def prepareAsync[P[_], F[_], Rev <: HList]()(implicit session: Session, executor: ExecutionContextExecutor, keySpace: KeySpace, ev: =:!=[PS, HNil], rev: Aux[PS, Rev], fMonad: Monad[F], adapter: GuavaAdapter[F], interface: PromiseInterface[P, F]): F[PreparedSelectBlock[Table, Record, Limit, Rev]]

val qb: CQLQuery

def queryString: String

val rowFunc: (Row) ⇒ Record

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

val table: Table

def using(clause: Condition): SelectQuery[Table, Record, Limit, Order, Status, Chainned, PS]

val usingPart: UsingPart

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def where[RR, HL <: HList, Out <: HList](condition: (Table) ⇒ QueryCondition[HL])(implicit ev: =:=[Chain, Unchainned], prepend: shapeless.ops.hlist.Prepend.Aux[HL, PS, Out]): QueryType[Table, Record, Limit, Order, Status, Chainned, Out]

val wherePart: WherePart

Inherited from Serializable

Inherited from Serializable

Inherited from Product

Inherited from Equals

Inherited from Query[Table, Record, Limit, Order, Status, Chain, PS]

Inherited from RootQuery[Table, Record, Status]

Inherited from SessionAugmenterImplicits

Inherited from AnyRef

Inherited from Any

Ungrouped