WrappingQuery

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

def ++[O >: E, R, D[_]](other: Query[O, U, D]): Query[O, U, C]

Return a new query containing the elements from both operands.

def ->[B](y: B): (WrappingQuery[E, U, C], B)

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def distinct: Query[E, U, C]

Remove duplicate elements.

def distinctOn[F, T](f: (E) ⇒ F)(implicit shape: Shape[_ <: FlatShapeLevel, F, T, _]): Query[E, U, C]

Remove duplicate elements which are the same in the given projection.

def drop(num: Int): Query[E, U, C]

Select all elements except the first num ones.

def drop(num: Long): Query[E, U, C]

Select all elements except the first num ones.

def drop(num: ConstColumn[Long]): Query[E, U, C]

Select all elements except the first num ones.

def encodeRef(path: Node): Query[E, U, C]

Encode a reference into this Rep.

def ensuring(cond: (WrappingQuery[E, U, C]) ⇒ Boolean, msg: ⇒ Any): WrappingQuery[E, U, C]

def ensuring(cond: (WrappingQuery[E, U, C]) ⇒ Boolean): WrappingQuery[E, U, C]

def ensuring(cond: Boolean, msg: ⇒ Any): WrappingQuery[E, U, C]

def ensuring(cond: Boolean): WrappingQuery[E, U, C]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def exists: Rep[Boolean]

Test whether this query is non-empty.

def filter[T <: Rep[_]](f: (E) ⇒ T)(implicit wt: CanBeQueryCondition[T]): Query[E, U, C]

Select all elements of this query which satisfy a predicate.

def filterNot[T <: Rep[_]](f: (E) ⇒ T)(implicit wt: CanBeQueryCondition[T]): Query[E, U, C]

def finalize(): Unit

def flatMap[F, T, D[_]](f: (E) ⇒ Query[F, T, D]): Query[F, T, C]

Build a new query by applying a function to all elements of this query and using the elements of the resulting queries.

def forUpdate: Query[E, U, C]

Specify part of a select statement for update and marked for row level locking

def formatted(fmtstr: String): String

final def getClass(): Class[_]

def groupBy[K, T, G, P](f: (E) ⇒ K)(implicit kshape: Shape[_ <: FlatShapeLevel, K, T, G], vshape: Shape[_ <: FlatShapeLevel, E, _, P]): Query[(G, Query[P, U, Seq]), (T, Query[P, U, Seq]), C]

Partition this query into a query of pairs of a key and a nested query containing the elements for the key, according to some discriminator function.

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def join[E2, U2, D[_]](q2: Query[E2, U2, D]): BaseJoinQuery[E, E2, U, U2, C, E, E2]

Join two queries with a cross join or inner join.

def joinFull[E1 >: E, E2, U2, D[_], O1, U1, O2](q2: Query[E2, _, D])(implicit ol1: OptionLift[E1, O1], sh1: Shape[FlatShapeLevel, O1, U1, _], ol2: OptionLift[E2, O2], sh2: Shape[FlatShapeLevel, O2, U2, _]): BaseJoinQuery[O1, O2, U1, U2, C, E, E2]

Join two queries with a full outer join.

def joinLeft[E2, U2, D[_], O2](q2: Query[E2, _, D])(implicit ol: OptionLift[E2, O2], sh: Shape[FlatShapeLevel, O2, U2, _]): BaseJoinQuery[E, O2, U, U2, C, E, E2]

Join two queries with a left outer join.

def joinRight[E1 >: E, E2, U2, D[_], O1, U1](q2: Query[E2, U2, D])(implicit ol: OptionLift[E1, O1], sh: Shape[FlatShapeLevel, O1, U1, _]): BaseJoinQuery[O1, E2, U1, U2, C, E, E2]

Join two queries with a right outer join.

def length: Rep[Int]

The total number of elements (i.e.

def map[F, G, T](f: (E) ⇒ F)(implicit shape: Shape[_ <: FlatShapeLevel, F, T, G]): Query[G, T, C]

Build a new query by applying a function to all elements of this query.

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def pack[R](implicit packing: Shape[_ <: FlatShapeLevel, E, _, R]): Query[R, U, C]

final lazy val packed: Node

val shaped: ShapedValue[_ <: E, U]

def size: Rep[Int]

The total number of elements (i.e.

def sortBy[T](f: (E) ⇒ T)(implicit ev: (T) ⇒ Ordered): Query[E, U, C]

Sort this query according to a function which extracts the ordering criteria from the query's elements.

def sorted(implicit ev: (E) ⇒ Ordered): Query[E, U, C]

Sort this query according to a the ordering of its elements.

def subquery: Query[E, U, C]

Force a subquery to be created when using this Query as part of a larger Query.

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

def take(num: Int): Query[E, U, C]

Select the first num elements.

def take(num: Long): Query[E, U, C]

Select the first num elements.

def take(num: ConstColumn[Long]): Query[E, U, C]

Select the first num elements.

def to[D[_]](implicit ctc: TypedCollectionTypeConstructor[D]): Query[E, U, D]

Change the collection type to build when executing the query.

val toNode: Node

Get the Node for this Rep.

def toString(): String

def union[O >: E, R, D[_]](other: Query[O, U, D]): Query[O, U, C]

Return a new query containing the elements from both operands.

def unionAll[O >: E, R, D[_]](other: Query[O, U, D]): Query[O, U, C]

Return a new query containing the elements from both operands.

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withFilter[T](f: (E) ⇒ T)(implicit arg0: CanBeQueryCondition[T]): Query[E, U, C]

Select all elements of this query which satisfy a predicate.

def zip[E2, U2, D[_]](q2: Query[E2, U2, D]): Query[(E, E2), (U, U2), C]

Return a query formed from this query and another query by combining corresponding elements in pairs.

def zipWith[E2, U2, F, G, T, D[_]](q2: Query[E2, U2, D], f: (E, E2) ⇒ F)(implicit shape: Shape[_ <: FlatShapeLevel, F, T, G]): Query[G, T, C]

Return a query formed from this query and another query by combining corresponding elements with the specified function.

def zipWithIndex: BaseJoinQuery[E, Rep[Long], U, Long, C, E, Rep[Long]]

Zip this query with its indices (starting at 0).

def →[B](y: B): (WrappingQuery[E, U, C], B)

def countDistinct: Rep[Int]

The number of distinct elements of the query.