Relation2

Instance Constructors

new Relation2(parameters: Parameters[T, (T, J1), S], queryable: dsl.Queryable[T], joinTable: dsl.Queryable[J1], on: ((T, J1)) ⇒ dsl.LogicalBoolean)(implicit manifest: Manifest[T])

Type Members

type Inc[A <: AR] = (T) ⇒ ActiveRecord.Association[T, A]

Definition Classes
QuerySupport
type JoinedType = (T, J1)

Definition Classes
Relation2 → QuerySupport
type TupleN = AnyRef { def _1: T }

Definition Classes
QuerySupport

Value Members

final def !=(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def !=(arg0: Any): Boolean

Definition Classes
Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def ==(arg0: Any): Boolean

Definition Classes
Any
final def asInstanceOf[T0]: T0

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

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

Definition Classes
Relation
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
lazy val companion: ActiveRecordBaseCompanion[_, T]

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

Definition Classes
Relation
def conditions: List[((T, J1)) ⇒ dsl.LogicalBoolean]

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

Attributes
protected
Definition Classes
Relation
def copyParams[R](params: Parameters[T, (T, J1), R]): Relation2[T, J1, R]

Attributes
protected
Definition Classes
Relation2 → QuerySupport
def copyParams[R](conditions: List[((T, J1)) ⇒ dsl.LogicalBoolean] = parameters.conditions, orders: List[((T, J1)) ⇒ dsl.ExpressionNode] = parameters.orders, selector: ((T, J1)) ⇒ 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]

Attributes
protected
Definition Classes
QuerySupport
def count: Long

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

Definition Classes
Relation
def distinct: Relation2.this.type

Definition Classes
QuerySupport
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
Relation
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def findAllBy(name: String, value: Any): Relation2.this.type

Search by fieldname and value.
Search by fieldname and value.
```
findAllBy("name", "abc")
```
name
field name
value
field value

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

Search by multiple fieldnames and values.
Search by multiple fieldnames and values.
```
findAllBy("name" -> "abc", "email" -> "[email protected]")
```
condition
fieldname-value tuple
conditions
multiple fieldname-value tuples(optional)

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

Search by fieldname and value and return first record.
Search by fieldname and value and return first record.
```
findBy("name", "abc")
```
name
field name
value
field value

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

Search by multiple fieldnames and values and return first record.
Search by multiple fieldnames and values and return first record.
```
findBy("name" -> "abc", "email" -> "[email protected]")
```
condition
fieldname-value tuple
conditions
multiple fieldname-value tuples(optional)

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

Definition Classes
Relation
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def head: S

Definition Classes
Relation
def headOption: Option[S]

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

Definition Classes
QuerySupport
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]): Relation2.this.type

Definition Classes
QuerySupport
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]): Relation2.this.type

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

Definition Classes
QuerySupport
def includes[A <: AR](association: (T) ⇒ ActiveRecord.Association[T, A]): Relation2.this.type

Definition Classes
QuerySupport
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def isLoaded: Boolean

Definition Classes
Relation
def isReverse: Boolean

Definition Classes
QuerySupport
def isUnique: Boolean

Definition Classes
QuerySupport
val joinTable: dsl.Queryable[J1]
def last: S

Definition Classes
Relation
def lastOption: Option[S]

Definition Classes
Relation
def limit(count: Int): Relation2.this.type

returns limited results.
returns limited results.
```
Post.all.orderBy(p => p.updatedAt desc).limit(10)
```
count
max count

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

Definition Classes
Relation
implicit val manifest: Manifest[T]

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

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

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

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

Definition Classes
Relation
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def not(condition: (T) ⇒ dsl.LogicalBoolean): Relation2.this.type

Definition Classes
QuerySupport
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
val on: ((T, J1)) ⇒ dsl.LogicalBoolean
def orderBy(conditions: (T, J1) ⇒ dsl.ExpressionNode*): Relation2.this.type
def orderBy(conditions: (T) ⇒ dsl.ExpressionNode*): Relation2.this.type

Definition Classes
QuerySupport
def orders: List[((T, J1)) ⇒ dsl.ExpressionNode]

Definition Classes
QuerySupport
def ordersExpression(m: (T, J1)): List[dsl.ExpressionNode]

Attributes
protected
Definition Classes
QuerySupport
def page(offset: Int, count: Int): Relation2.this.type

returns page results.
returns page results.
```
Post.all.orderBy(p => p.updatedAt desc).page(10 * (pageNumber - 1), 10)
```
offset
offset count
count
max count

Definition Classes
QuerySupport
def pages: Option[(Int, Int)]

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

Attributes
protected
Definition Classes
QuerySupport
val parameters: Parameters[T, (T, J1), S]

Definition Classes
Relation2 → QuerySupport
val queryable: dsl.Queryable[T]

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

Attributes
protected
Definition Classes
QuerySupport
def reload(implicit m: Manifest[S]): List[S]

Definition Classes
Relation
def reverse: Relation2.this.type

Definition Classes
QuerySupport
def reverseOrder(m: (T, J1)): List[dsl.OrderByExpression]

Attributes
protected
Definition Classes
QuerySupport
def select[R](selector: (T, J1) ⇒ R): Relation[T, R]
def select[R](selector: (T) ⇒ R): Relation[T, R]

Definition Classes
QuerySupport
def selector: ((T, J1)) ⇒ S

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

Definition Classes
Relation
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toQuery[R](f: ((T, J1)) ⇒ dsl.QueryYield[R]): dsl.Query[R]

Attributes
protected
Definition Classes
Relation2 → Relation
def toQuery: dsl.Query[S]

Definition Classes
Relation
def toSql: String

Definition Classes
Relation
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
def where(condition: (T, J1) ⇒ dsl.LogicalBoolean): Relation2.this.type
def where(condition: (T) ⇒ dsl.LogicalBoolean): Relation2.this.type

Definition Classes
QuerySupport
def whereScope(m: (T, J1)): WhereState[_ >: Unconditioned with Conditioned <: AnyRef]

Attributes
protected
Definition Classes
QuerySupport
def wrap[A <: TupleN, R](f: (T) ⇒ R): (A) ⇒ R

Attributes
protected
Definition Classes
QuerySupport
def wrapTuple1[A <: TupleN, R](f: ((T)) ⇒ R): (A) ⇒ R

Attributes
protected
Definition Classes
QuerySupport

case class Relation2[T <: AR, J1 <: AR, S](parameters: Parameters[T, (T, J1), S], queryable: dsl.Queryable[T], joinTable: dsl.Queryable[J1], on: ((T, J1)) ⇒ dsl.LogicalBoolean)(implicit manifest: Manifest[T]) extends Relation[T, S] with Product with Serializable

Instance Constructors

new Relation2(parameters: Parameters[T, (T, J1), S], queryable: dsl.Queryable[T], joinTable: dsl.Queryable[J1], on: ((T, J1)) ⇒ dsl.LogicalBoolean)(implicit manifest: Manifest[T])

Type Members

type Inc[A <: AR] = (T) ⇒ ActiveRecord.Association[T, A]

type JoinedType = (T, J1)

type TupleN = AnyRef { def _1: T }

Value Members

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, J1) ⇒ dsl.TypedExpression[T1, _]): T1

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

def conditions: List[((T, J1)) ⇒ dsl.LogicalBoolean]

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

def copyParams[R](params: Parameters[T, (T, J1), R]): Relation2[T, J1, R]

def count: Long

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

def distinct: Relation2.this.type

final def eq(arg0: AnyRef): Boolean

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

def finalize(): Unit

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

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

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

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

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

final def getClass(): Class[_]

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]): Relation2.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]): Relation2.this.type

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

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

final def isInstanceOf[T0]: Boolean

def isLoaded: Boolean

def isReverse: Boolean

def isUnique: Boolean

val joinTable: dsl.Queryable[J1]

def last: S

def lastOption: Option[S]

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

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

implicit val manifest: Manifest[T]

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): Relation2.this.type

final def notify(): Unit

final def notifyAll(): Unit

val on: ((T, J1)) ⇒ dsl.LogicalBoolean

def orderBy(conditions: (T, J1) ⇒ dsl.ExpressionNode*): Relation2.this.type

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

def orders: List[((T, J1)) ⇒ dsl.ExpressionNode]

def ordersExpression(m: (T, J1)): List[dsl.ExpressionNode]

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

def pages: Option[(Int, Int)]

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

val parameters: Parameters[T, (T, J1), S]

val queryable: dsl.Queryable[T]

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

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

def reverse: Relation2.this.type

def reverseOrder(m: (T, J1)): List[dsl.OrderByExpression]

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

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

def selector: ((T, J1)) ⇒ 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