WrappingQuery

final def !=(arg0: AnyRef): Boolean

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: AnyRef): Boolean

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def countDistinct: Column[Int]

The number of distinct elements of the query.

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: List[ast.Symbol]): 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: Column[Boolean]

Test whether this query is non-empty.

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

Select all elements of this query which satisfy a predicate.

def filterNot[T <: Column[_]](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 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

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

Join two collections with an inner join.

final def isInstanceOf[T0]: Boolean

def join[E2, U2, D[_]](q2: Query[E2, U2, D], jt: JoinType = JoinType.Inner): BaseJoinQuery[E, E2, U, U2, C]

Join two collections.

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

Join two collections with a left outer join.

def length: Column[Int]

The total number of elements (i.

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 outerJoin[E2, U2, D[_]](q2: Query[E2, U2, D]): BaseJoinQuery[E, E2, U, U2, C]

Join two collections with a full outer join.

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

final lazy val packed: Node

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

Join two collections with a right outer join.

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

def size: Column[Int]

The total number of elements (i.

def sortBy[T](f: (E) ⇒ T)(implicit arg0: (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.

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]

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, Column[Long], U, Long, C]

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

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

val self: Any

val self: Any

def where[T <: Column[_]](f: (E) ⇒ T)(implicit arg0: CanBeQueryCondition[T]): Query[E, U, C]

Select all elements of this query which satisfy a predicate.

def x: WrappingQuery[E, U, C]

def x: WrappingQuery[E, U, C]