Version

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def all: ActiveRecord.Relation1[Version, Version]

all search.

final def asInstanceOf[T0]: T0

def assignValue(value: Any, fieldInfo: FieldInfo): Any

def bind(data: Map[String, String])(implicit source: Version = self.newInstance): Version

lazy val classInfo: ClassInfo[Version]

ProductModel class information

def clone(): AnyRef

implicit def companionToIterable(c: Version.this.type): List[Version]

implicit def companionToRelation(c: Version.this.type): ActiveRecord.Relation1[Version, Version]

def create(model: Version): Unit

insert record from model.

def defaultScope: ActiveRecord.Relation1[Version, Version]

def delete(id: Long): Boolean

delete record from id.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

lazy val fieldInfo: Map[String, FieldInfo]

ProductModel fields information

lazy val fields: List[FieldInfo]

def find(id: Long): Option[Version]

search by id.

def forceDelete(condition: (Version) ⇒ dsl.LogicalBoolean): Int

def forceDeleteAll(): Int

def forceInsertAll(models: Version*): Unit

def forceInsertAll(models: Iterable[Version]): Unit

def forceUpdate(condition: (Version) ⇒ dsl.LogicalBoolean)(updateAssignments: (Version) ⇒ dsl.UpdateAssignment*): Int

def forceUpdateAll(updateAssignments: (Version) ⇒ dsl.UpdateAssignment*): Int

def fromArrayJson(json: String): List[Version]

def fromJArray(jarray: JValue, throws: Boolean = false): List[Version]

def fromJValue(jvalue: JValue, throws: Boolean = false): Version

def fromJson(json: String): Version

def fromMap(data: Map[String, Any]): Version

final def getClass(): Class[_]

def hashCode(): Int

def inTransaction[R](f: ⇒ R): R

def insertWithValidation(models: Version*): Iterable[Version]

def insertWithValidation(models: Iterable[Version]): Iterable[Version]

final def isInstanceOf[T0]: Boolean

lazy val isOptimistic: Boolean

def isRequired(name: String): Boolean

def isUnique(name: String, m: Version): Boolean

unique validation.

implicit val keyedEntityDef: dsl.KeyedEntityDef[Version, Long] { val idPropertyName: String }

implicit val manifest: ClassTag[Version]

final def ne(arg0: AnyRef): Boolean

macro def newInstance(data: (String, Any)*): Version

def newInstance: Version

Create a new model object.

final def notify(): Unit

final def notifyAll(): Unit

lazy val schema: ActiveRecordTables

database schema

def self: Version.this.type

self reference

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

lazy val table: dsl.Table[Version]

corresponding database table

lazy val targetClass: Class[Version]

corresponding model class

implicit val toCanLookup: (Long) ⇒ dsl.CanLookup

def toString(): String

def transaction[R](f: ⇒ R): R

def unbind(m: Version): Map[String, String]

lazy val uniqueFields: List[FieldInfo]

Unique annotated fields

def unsafeAssign(data: Map[String, Any], assignFunc: (Any, FieldInfo) ⇒ Any, throws: Boolean = true)(implicit source: Version = self.newInstance): Version

def update(model: Version): Unit

update record from model.

lazy val validatableFields: List[FieldInfo]

lazy val validators: Map[String, Seq[(Annotation, Validator[_])]]

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

final def wait(arg0: Long): Unit

final def wait(): Unit

def finalize(): Unit