AbstractQuery

abstract def ast: QueryExpressionNode[R]

abstract def createCopy(asRoot: Boolean): AbstractQuery[R]

abstract def invokeYield(rsm: ResultSetMapper, resultSet: ResultSet): R

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def ++[B >: R, That](that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[Iterable[R], B, That]): That

def ++:[B >: R, That](that: Traversable[B])(implicit bf: CanBuildFrom[Iterable[R], B, That]): That

def ++:[B >: R, That](that: TraversableOnce[B])(implicit bf: CanBuildFrom[Iterable[R], B, That]): That

def /:[B](z: B)(op: (B, R) ⇒ B): B

def /:\[A1 >: R](z: A1)(op: (A1, A1) ⇒ A1): A1

def :\[B](z: B)(op: (R, B) ⇒ B): B

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def addString(b: StringBuilder): StringBuilder

def addString(b: StringBuilder, sep: String): StringBuilder

def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder

def aggregate[B](z: B)(seqop: (B, R) ⇒ B, combop: (B, B) ⇒ B): B

final def asInstanceOf[T0]: T0

def buildAst(qy: QueryYield[R], subQueryables: AbstractQuery.this.SubQueryable[_]*): QueryExpressionNode[R]

def canEqual(that: Any): Boolean

def clone(): AnyRef

def collect[B, That](pf: PartialFunction[R, B])(implicit bf: CanBuildFrom[Iterable[R], B, That]): That

def collectFirst[B](pf: PartialFunction[R, B]): Option[B]

def companion: GenericCompanion[Iterable]

def copy(asRoot: Boolean): AbstractQuery[R]

def copyToArray[B >: R](xs: Array[B], start: Int, len: Int): Unit

def copyToArray[B >: R](xs: Array[B]): Unit

def copyToArray[B >: R](xs: Array[B], start: Int): Unit

def copyToBuffer[B >: R](dest: Buffer[B]): Unit

def count(p: (R) ⇒ Boolean): Int

def createSubQueryable[U](q: Queryable[U]): SubQueryable[U]

val definitionSite: Option[StackTraceElement]

Builds the AST tree of the this Query, *some state mutation of the AST nodes occurs during AST construction, for example, the parent child relationship is set by this method, unique IDs of node that needs them for example.

def distinct: AbstractQuery[R]

def drop(n: Int): Iterable[R]

def dropRight(n: Int): Iterable[R]

def dropWhile(p: (R) ⇒ Boolean): Iterable[R]

def dumpAst: String

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def exists(p: (R) ⇒ Boolean): Boolean

def filter(p: (R) ⇒ Boolean): Iterable[R]

def filterNot(p: (R) ⇒ Boolean): Iterable[R]

def finalize(): Unit

def find(p: (R) ⇒ Boolean): Option[R]

def flatMap[B, That](f: (R) ⇒ GenTraversableOnce[B])(implicit bf: CanBuildFrom[Iterable[R], B, That]): That

def fold[A1 >: R](z: A1)(op: (A1, A1) ⇒ A1): A1

def foldLeft[B](z: B)(op: (B, R) ⇒ B): B

def foldRight[B](z: B)(op: (R, B) ⇒ B): B

def forUpdate: AbstractQuery[R]

def forall(p: (R) ⇒ Boolean): Boolean

def foreach[U](f: (R) ⇒ U): Unit

def genericBuilder[B]: Builder[B, Iterable[B]]

final def getClass(): java.lang.Class[_]

def give(rsm: ResultSetMapper, rs: ResultSet): R

def groupBy[K](f: (R) ⇒ K): Map[K, Iterable[R]]

def grouped(size: Int): Iterator[Iterable[R]]

def hasDefiniteSize: Boolean

def hashCode(): Int

def head: R

def headOption: Option[R]

def init: Iterable[R]

def inits: Iterator[Iterable[R]]

def isEmpty: Boolean

final def isInstanceOf[T0]: Boolean

val isRoot: Boolean

final def isTraversableAgain: Boolean

def iterator: Iterator[R] with Closeable

def last: R

def lastOption: Option[R]

def map[B, That](f: (R) ⇒ B)(implicit bf: CanBuildFrom[Iterable[R], B, That]): That

def max[B >: R](implicit cmp: Ordering[B]): R

def maxBy[B](f: (R) ⇒ B)(implicit cmp: Ordering[B]): R

def min[B >: R](implicit cmp: Ordering[B]): R

def minBy[B](f: (R) ⇒ B)(implicit cmp: Ordering[B]): R

def minus(q: Query[R]): Query[R]

def mkString: String

def mkString(sep: String): String

def mkString(start: String, sep: String, end: String): String

val name: String

final def ne(arg0: AnyRef): Boolean

def newBuilder: Builder[R, Iterable[R]]

def nonEmpty: Boolean

final def notify(): Unit

final def notifyAll(): Unit

def page(offset: Int, pageLength: Int): Query[R]

def par: ParIterable[R]

def parCombiner: Combiner[R, ParIterable[R]]

def partition(p: (R) ⇒ Boolean): (Iterable[R], Iterable[R])

def product[B >: R](implicit num: Numeric[B]): B

def reduce[A1 >: R](op: (A1, A1) ⇒ A1): A1

def reduceLeft[B >: R](op: (B, R) ⇒ B): B

def reduceLeftOption[B >: R](op: (B, R) ⇒ B): Option[B]

def reduceOption[A1 >: R](op: (A1, A1) ⇒ A1): Option[A1]

def reduceRight[B >: R](op: (R, B) ⇒ B): B

def reduceRightOption[B >: R](op: (R, B) ⇒ B): Option[B]

def repr: Iterable[R]

val resultSetMapper: ResultSetMapper

def reversed: List[R]

def sameElements[B >: R](that: GenIterable[B]): Boolean

def scan[B >: R, That](z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[Iterable[R], B, That]): That

def scanLeft[B, That](z: B)(op: (B, R) ⇒ B)(implicit bf: CanBuildFrom[Iterable[R], B, That]): That

def scanRight[B, That](z: B)(op: (R, B) ⇒ B)(implicit bf: CanBuildFrom[Iterable[R], B, That]): That

def seq: Iterable[R]

def single: R

Returns the first row of the query.

def size: Int

def slice(from: Int, until: Int): Iterable[R]

def sliding[B >: R](size: Int, step: Int): Iterator[Iterable[R]]

def sliding[B >: R](size: Int): Iterator[Iterable[R]]

def span(p: (R) ⇒ Boolean): (Iterable[R], Iterable[R])

def splitAt(n: Int): (Iterable[R], Iterable[R])

def statement: String

returns a 'pretty' statement, i.

def stringPrefix: String

def sum[B >: R](implicit num: Numeric[B]): B

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

def tail: Iterable[R]

def tails: Iterator[Iterable[R]]

def take(n: Int): Iterable[R]

def takeRight(n: Int): Iterable[R]

def takeWhile(p: (R) ⇒ Boolean): Iterable[R]

def thisCollection: Iterable[R]

def toArray[B >: R](implicit arg0: ClassManifest[B]): Array[B]

def toBuffer[B >: R]: Buffer[B]

def toCollection(repr: Iterable[R]): Iterable[R]

def toIndexedSeq[B >: R]: IndexedSeq[B]

def toIterable: Iterable[R]

def toIterator: Iterator[R]

def toList: List[R]

def toMap[T, U](implicit ev: <:<[R, (T, U)]): Map[T, U]

def toSeq: Seq[R]

def toSet[B >: R]: Set[B]

def toStream: Stream[R]

def toString(): String

def toTraversable: Traversable[R]

def transpose[B](implicit asTraversable: (R) ⇒ GenTraversableOnce[B]): Iterable[Iterable[B]]

def union(q: Query[R]): Query[R]

def unzip[A1, A2](implicit asPair: (R) ⇒ (A1, A2)): (Iterable[A1], Iterable[A2])

def unzip3[A1, A2, A3](implicit asTriple: (R) ⇒ (A1, A2, A3)): (Iterable[A1], Iterable[A2], Iterable[A3])

def view(from: Int, until: Int): IterableView[R, Iterable[R]]

def view: IterableView[R, Iterable[R]]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def where(whereClauseFunctor: (R) ⇒ LogicalBoolean)(implicit dsl: QueryDsl): Query[R]

def withFilter(p: (R) ⇒ Boolean): FilterMonadic[R, Iterable[R]]

def zip[A1 >: R, B, That](that: GenIterable[B])(implicit bf: CanBuildFrom[Iterable[R], (A1, B), That]): That

def zipAll[B, A1 >: R, That](that: GenIterable[B], thisElem: A1, thatElem: B)(implicit bf: CanBuildFrom[Iterable[R], (A1, B), That]): That

def zipWithIndex[A1 >: R, That](implicit bf: CanBuildFrom[Iterable[R], (A1, Int), That]): That

def elements: Iterator[R]

def first: R

def firstOption: Option[R]

def projection: IterableView[R, Iterable[R]]