AbstractQuery

abstract def ast: QueryExpressionNode[R]

abstract def createCopy(asRoot: Boolean, newUnions: List[(String, Query[R])]): AbstractQuery[R]

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

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

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

def clone(): AnyRef

def copy(asRoot: Boolean, newUnions: List[(String, Query[R])]): AbstractQuery[R]

def copyUnions(u: List[(String, Query[R])]): List[(String, Query[R])]

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 dumpAst: String

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

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

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

def finalize(): Unit

def forUpdate: AbstractQuery[R]

final def getClass(): Class[_]

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

def hashCode(): Int

def headOption: Option[R]

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

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

final def isInstanceOf[T0]: Boolean

val isRoot: Boolean

def iterator: Iterator[R] with Closeable

val name: String

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

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

val resultSetMapper: ResultSetMapper

def single: R

Returns the first row of the query.

def singleOption: Option[R]

Returns Some(singleRow), None if there are none, throws an exception if the query returns more than one row.

def statement: String

returns a 'pretty' statement, i.e.

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

def toString(): String

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

def unionAll(q: Query[R]): Query[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]