Relation

abstract def copyParams[R](params: Parameters[T, JoinedType, R]): Relation[T, R]

abstract val manifest: Manifest[T]

abstract val parameters: Parameters[T, JoinedType, S]

abstract val queryable: dsl.Queryable[T]

abstract def toQuery[R](f: (JoinedType) ⇒ dsl.QueryYield[R]): dsl.Query[R]

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def average[T2 >: dsl.TOptionFloat, T1 <: T2, A1, A2](e: (T) ⇒ dsl.TypedExpression[A1, T1])(implicit f: dsl.TypedExpressionFactory[A2, T2]): A2

def avg[T2 >: dsl.TOptionFloat, T1 <: T2, A1, A2](e: (T) ⇒ dsl.TypedExpression[A1, T1])(implicit f: dsl.TypedExpressionFactory[A2, T2]): A2

def clone(): AnyRef

lazy val companion: ActiveRecordBaseCompanion[_, T]

def compute[T1](e: (T) ⇒ dsl.TypedExpression[T1, _]): T1

def conditions: List[(JoinedType) ⇒ dsl.LogicalBoolean]

implicit def convertFactory[A](f: dsl.TypedExpressionFactory[A, _]): dsl.TypedExpressionFactory[A, Any]

def copyParams[R](conditions: List[(JoinedType) ⇒ dsl.LogicalBoolean] = parameters.conditions, orders: List[(JoinedType) ⇒ dsl.ExpressionNode] = parameters.orders, selector: (JoinedType) ⇒ R = parameters.selector, includeAssociations: List[(T) ⇒ ActiveRecord.Association[T, AR]] = parameters.includeAssociations, pages: Option[(Int, Int)] = parameters.pages, isUnique: Boolean = parameters.isUnique, isReverse: Boolean = parameters.isReverse): Relation[T, R]

def count: Long

def deleteAll()(implicit ev: =:=[S, T]): List[T]

def distinct: Relation.this.type

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def exists(condition: (T) ⇒ dsl.LogicalBoolean): Boolean

def finalize(): Unit

def findAllBy(name: String, value: Any): Relation.this.type

Search by fieldname and value.

findAllBy("name", "abc")

def findAllBy(condition: (String, Any), conditions: (String, Any)*): Relation.this.type

Search by multiple fieldnames and values.

findAllBy("name" -> "abc", "email" -> "[email protected]")

def findBy(name: String, value: Any): Option[S]

Search by fieldname and value and return first record.

findBy("name", "abc")

def findBy(condition: (String, Any), conditions: (String, Any)*): Option[S]

Search by multiple fieldnames and values and return first record.

findBy("name" -> "abc", "email" -> "[email protected]")

def findByOrCreate(m: T, field: String, fields: String*)(implicit ev: =:=[T, S]): S

final def getClass(): Class[_]

def hashCode(): Int

def head: S

def headOption: Option[S]

def includeAssociations: List[(T) ⇒ ActiveRecord.Association[T, AR]]

def includes[A1 <: AR, A2 <: AR, A3 <: AR, A4 <: AR](a1: (T) ⇒ ActiveRecord.Association[T, A1], a2: (T) ⇒ ActiveRecord.Association[T, A2], a3: (T) ⇒ ActiveRecord.Association[T, A3], a4: (T) ⇒ ActiveRecord.Association[T, A4]): Relation.this.type

def includes[A1 <: AR, A2 <: AR, A3 <: AR](a1: (T) ⇒ ActiveRecord.Association[T, A1], a2: (T) ⇒ ActiveRecord.Association[T, A2], a3: (T) ⇒ ActiveRecord.Association[T, A3]): Relation.this.type

def includes[A1 <: AR, A2 <: AR](a1: (T) ⇒ ActiveRecord.Association[T, A1], a2: (T) ⇒ ActiveRecord.Association[T, A2]): Relation.this.type

def includes[A <: AR](association: (T) ⇒ ActiveRecord.Association[T, A]): Relation.this.type

final def isInstanceOf[T0]: Boolean

def isLoaded: Boolean

def isReverse: Boolean

def isUnique: Boolean

def last: S

def lastOption: Option[S]

def limit(count: Int): Relation.this.type

returns limited results.

Post.all.orderBy(p => p.updatedAt desc).limit(10)

def load(implicit m: Manifest[S]): List[S]

def max[T2 >: dsl.TOption, T1 <: T2, A1, A2](e: (T) ⇒ dsl.TypedExpression[A1, T1])(implicit f: dsl.TypedExpressionFactory[A2, T2]): A2

def maximum[T2 >: dsl.TOption, T1 <: T2, A1, A2](e: (T) ⇒ dsl.TypedExpression[A1, T1])(implicit f: dsl.TypedExpressionFactory[A2, T2]): A2

def min[T2 >: dsl.TOption, T1 <: T2, A1, A2](e: (T) ⇒ dsl.TypedExpression[A1, T1])(implicit f: dsl.TypedExpressionFactory[A2, T2]): A2

def minimum[T2 >: dsl.TOption, T1 <: T2, A1, A2](e: (T) ⇒ dsl.TypedExpression[A1, T1])(implicit f: dsl.TypedExpressionFactory[A2, T2]): A2

final def ne(arg0: AnyRef): Boolean

def not(condition: (T) ⇒ dsl.LogicalBoolean): Relation.this.type

final def notify(): Unit

final def notifyAll(): Unit

def orderBy(conditions: (T) ⇒ dsl.ExpressionNode*): Relation.this.type

def orders: List[(JoinedType) ⇒ dsl.ExpressionNode]

def ordersExpression(m: JoinedType): List[dsl.ExpressionNode]

def page(offset: Int, count: Int): Relation.this.type

returns page results.

Post.all.orderBy(p => p.updatedAt desc).page(10 * (pageNumber - 1), 10)

def pages: Option[(Int, Int)]

def paginate[R](query: dsl.Query[R]): Query[R]

implicit def relationToThisType[R](self: Relation[T, R]): Relation.this.type

def reload(implicit m: Manifest[S]): List[S]

def reverse: Relation.this.type

def reverseOrder(m: JoinedType): List[dsl.OrderByExpression]

def select[R](selector: (T) ⇒ R): Relation[T, R]

def selector: (JoinedType) ⇒ S

def sum[T2 >: dsl.TOption, T1 >: dsl.TNumericLowerTypeBound <: T2, A1, A2](e: (T) ⇒ dsl.TypedExpression[A1, T1])(implicit f: dsl.TypedExpressionFactory[A2, T2]): A2

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

def toQuery: dsl.Query[S]

def toSql: String

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def where(condition: (T) ⇒ dsl.LogicalBoolean): Relation.this.type

def whereScope(m: JoinedType): WhereState[_ >: Unconditioned with Conditioned <: AnyRef]

def wrap[A <: TupleN, R](f: (T) ⇒ R): (A) ⇒ R

def wrapTuple1[A <: TupleN, R](f: ((T)) ⇒ R): (A) ⇒ R