BaseJoinQuery

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

def ++[O >: (E1, E2), R, D[_]](other: Query[O, (U1, U2), D]): Query[O, (U1, U2), C]

Return a new query containing the elements from both operands.

def ->[B](y: B): (BaseJoinQuery[E1, E2, U1, U2, C, B1, B2], B)

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def countDistinct: Rep[Int]

The number of distinct elements of the query.

def drop(num: Int): Query[(E1, E2), (U1, U2), C]

Select all elements except the first num ones.

def drop(num: Long): Query[(E1, E2), (U1, U2), C]

Select all elements except the first num ones.

def drop(num: ConstColumn[Long]): Query[(E1, E2), (U1, U2), C]

Select all elements except the first num ones.

def encodeRef(path: Node): Query[(E1, E2), (U1, U2), C]

Encode a reference into this Rep.

def ensuring(cond: (BaseJoinQuery[E1, E2, U1, U2, C, B1, B2]) ⇒ Boolean, msg: ⇒ Any): BaseJoinQuery[E1, E2, U1, U2, C, B1, B2]

def ensuring(cond: (BaseJoinQuery[E1, E2, U1, U2, C, B1, B2]) ⇒ Boolean): BaseJoinQuery[E1, E2, U1, U2, C, B1, B2]

def ensuring(cond: Boolean, msg: ⇒ Any): BaseJoinQuery[E1, E2, U1, U2, C, B1, B2]

def ensuring(cond: Boolean): BaseJoinQuery[E1, E2, U1, U2, C, B1, B2]

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: ((E1, E2)) ⇒ T)(implicit wt: CanBeQueryCondition[T]): Query[(E1, E2), (U1, U2), C]

Select all elements of this query which satisfy a predicate.

def filterNot[T <: Rep[_]](f: ((E1, E2)) ⇒ T)(implicit wt: CanBeQueryCondition[T]): Query[(E1, E2), (U1, U2), C]

def finalize(): Unit

def flatMap[F, T, D[_]](f: ((E1, E2)) ⇒ 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: ((E1, E2)) ⇒ K)(implicit kshape: Shape[_ <: FlatShapeLevel, K, T, G], vshape: Shape[_ <: FlatShapeLevel, (E1, E2), _, P]): Query[(G, Query[P, (U1, U2), Seq]), (T, Query[P, (U1, U2), 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[(E1, E2), E2, (U1, U2), U2, C, (E1, E2), E2]

Join two queries with a cross join or inner join.

def joinFull[E1 >: (E1, E2), 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, (E1, E2), 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[(E1, E2), O2, (U1, U2), U2, C, (E1, E2), E2]

Join two queries with a left outer join.

def joinRight[E1 >: (E1, E2), 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, (E1, E2), E2]

Join two queries with a right outer join.

def length: Rep[Int]

The total number of elements (i.

def map[F, G, T](f: ((E1, E2)) ⇒ 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 on[T <: Rep[_]](pred: (B1, B2) ⇒ T)(implicit wt: CanBeQueryCondition[T]): Query[(E1, E2), (U1, U2), C]

Add a join condition to a join operation.

def pack[R](implicit packing: Shape[_ <: FlatShapeLevel, (E1, E2), _, R]): Query[R, (U1, U2), C]

final lazy val packed: Node

val shaped: ShapedValue[_ <: (E1, E2), (U1, U2)]

def size: Rep[Int]

The total number of elements (i.

def sortBy[T](f: ((E1, E2)) ⇒ T)(implicit arg0: (T) ⇒ Ordered): Query[(E1, E2), (U1, U2), C]

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

def sorted(implicit ev: ((E1, E2)) ⇒ Ordered): Query[(E1, E2), (U1, U2), C]

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

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

def take(num: Int): Query[(E1, E2), (U1, U2), C]

Select the first num elements.

def take(num: Long): Query[(E1, E2), (U1, U2), C]

Select the first num elements.

def take(num: ConstColumn[Long]): Query[(E1, E2), (U1, U2), C]

Select the first num elements.

def to[D[_]](implicit ctc: TypedCollectionTypeConstructor[D]): Query[(E1, E2), (U1, U2), D]

val toNode: Node

Get the Node for this Rep.

def toString(): String

def union[O >: (E1, E2), R, D[_]](other: Query[O, (U1, U2), D]): Query[O, (U1, U2), C]

Return a new query containing the elements from both operands.

def unionAll[O >: (E1, E2), R, D[_]](other: Query[O, (U1, U2), D]): Query[O, (U1, U2), 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: ((E1, E2)) ⇒ T)(implicit arg0: CanBeQueryCondition[T]): Query[(E1, E2), (U1, U2), C]

Select all elements of this query which satisfy a predicate.

def zip[E2, U2, D[_]](q2: Query[E2, U2, D]): Query[((E1, E2), E2), ((U1, U2), 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: ((E1, E2), 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[(E1, E2), Rep[Long], (U1, U2), Long, C, (E1, E2), Rep[Long]]

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

def →[B](y: B): (BaseJoinQuery[E1, E2, U1, U2, C, B1, B2], B)

val self: Any

val self: Any

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

Join two queries with a cross / inner join.

def join[E2, U2, D[_]](q2: Query[E2, U2, D], jt: JoinType): BaseJoinQuery[(E1, E2), E2, (U1, U2), U2, C, (E1, E2), E2]

Join two queries.

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

Join two queries with a left outer join.

def outerJoin[E2, U2, D[_]](q2: Query[E2, U2, D]): BaseJoinQuery[(E1, E2), E2, (U1, U2), U2, C, (E1, E2), E2]

Join two queries with a full outer join.

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

Join two queries with a right outer join.

def where[T <: Rep[_]](f: ((E1, E2)) ⇒ T)(implicit arg0: CanBeQueryCondition[T]): Query[(E1, E2), (U1, U2), C]

Select all elements of this query which satisfy a predicate.

def x: BaseJoinQuery[E1, E2, U1, U2, C, B1, B2]

def x: BaseJoinQuery[E1, E2, U1, U2, C, B1, B2]