BaseJoinQuery

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

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

Return a new query containing the elements from both operands.

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[(E1, E2), (U1, U2)]

Select all elements except the first num ones.

def encodeRef(path: List[ast.Symbol]): Query[(E1, E2), (U1, U2)]

Encode a reference into this Rep

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

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

def finalize(): Unit

def flatMap[F, T](f: ((E1, E2)) ⇒ Query[F, T]): Query[F, T]

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

final def getClass(): Class[_]

def groupBy[K, T, G, P](f: ((E1, E2)) ⇒ K)(implicit kshape: Shape[_ <: Flat, K, T, G], vshape: Shape[_ <: Flat, (E1, E2), _, P]): Query[(G, Query[P, (U1, U2)]), (T, Query[P, (U1, U2)])]

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](q2: Query[E2, U2]): BaseJoinQuery[(E1, E2), E2, (U1, U2), U2]

Join two collections with an inner join.

final def isInstanceOf[T0]: Boolean

def join[E2, U2](q2: Query[E2, U2], jt: JoinType = JoinType.Inner): BaseJoinQuery[(E1, E2), E2, (U1, U2), U2]

Join two collections.

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

Join two collections with a left outer join.

def length: Column[Int]

The total number of elements of the query.

def map[F, G, T](f: ((E1, E2)) ⇒ F)(implicit shape: Shape[_ <: Flat, F, T, G]): Query[G, T]

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 <: Column[_]](pred: (E1, E2) ⇒ T)(implicit wt: CanBeQueryCondition[T]): WrappingQuery[(E1, E2), (U1, U2)]

Add a join condition to a join operation.

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

Join two collections with a full outer join.

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

final lazy val packed: Node

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

Join two collections with a right outer join.

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

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)]

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)]

Select the first num elements.

val toNode: Node

Get the Node for this Rep

def toString(): String

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

Return a new query containing the elements from both operands.

def unionAll[O >: (E1, E2), R](other: Query[O, (U1, U2)]): WrappingQuery[O, (U1, U2)]

Return a new query containing the elements from both operands.

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

final def wait(): Unit

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

final def wait(arg0: Long): Unit

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

Select all elements of this query which satisfy a predicate.

def withFilter[T](f: ((E1, E2)) ⇒ T)(implicit arg0: CanBeQueryCondition[T]): Query[(E1, E2), (U1, U2)]

Select all elements of this query which satisfy a predicate.

def zip[E2, U2](q2: Query[E2, U2]): Query[((E1, E2), E2), ((U1, U2), U2)]

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

def zipWith[E2, U2, F, G, T](q2: Query[E2, U2], f: ((E1, E2), E2) ⇒ F)(implicit shape: Shape[_ <: Flat, F, T, G]): Query[G, T]

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

def zipWithIndex: BaseJoinQuery[(E1, E2), Column[Long], (U1, U2), Long]

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

def >>[F, T](q: Query[F, T]): Query[F, T]