ActiveRecordTables

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def afterDelete[A]()(implicit m: Manifest[A]): LifecycleEventPercursorClass[A]

def afterDelete[A](t: Table[A]): LifecycleEventPercursorTable[A]

def afterInsert[A]()(implicit m: Manifest[A]): LifecycleEventPercursorClass[A]

def afterInsert[A](t: Table[A]): LifecycleEventPercursorTable[A]

def afterSelect[A]()(implicit m: Manifest[A]): LifecycleEventPercursorClass[A]

def afterSelect[A](t: Table[A]): LifecycleEventPercursorTable[A]

def afterUpdate[A]()(implicit m: Manifest[A]): LifecycleEventPercursorClass[A]

def afterUpdate[A](t: Table[A]): LifecycleEventPercursorTable[A]

lazy val all: Iterable[Table[_ >: IntermediateRecord <: AR]]

All tables

def allSessions: Seq[AbstractSession]

implicit def anyRef2ActiveTransaction[A](a: A)(implicit queryDsl: QueryDsl, m: Manifest[A]): ActiveRecord[A]

def apply[T](config: Map[String, Any] = Map())(f: ⇒ T): T

def applyDefaultForeignKeyPolicy(foreignKeyDeclaration: ForeignKeyDeclaration): Unit

final def asInstanceOf[T0]: T0

def autoIncremented(sequenceName: String): AutoIncremented

def autoIncremented: AutoIncremented

lazy val baseARType: (Class[_]) ⇒ Option[scala.reflect.api.JavaUniverse.Symbol]

def beforeDelete[K, A]()(implicit m: Manifest[A], ked: KeyedEntityDef[A, K]): LifecycleEventPercursorClass[A]

def beforeDelete[A](t: Table[A])(implicit ev: KeyedEntityDef[A, _]): LifecycleEventPercursorTable[A]

def beforeInsert[A]()(implicit m: Manifest[A]): LifecycleEventPercursorClass[A]

def beforeInsert[A](t: Table[A]): LifecycleEventPercursorTable[A]

def beforeUpdate[A]()(implicit m: Manifest[A]): LifecycleEventPercursorClass[A]

def beforeUpdate[A](t: Table[A]): LifecycleEventPercursorTable[A]

def callbacks: Seq[LifecycleEvent]

def cleanup: Unit

cleanup database resources

def clone(): AnyRef

def columnNameFromPropertyName(propertyName: String): String

def columnTypeFor(fieldMetaData: FieldMetaData, owner: Table[_]): Option[String]

def columns(fieldList: TypedExpression[_, _]*): ColGroupDeclaration

def config: ActiveRecordConfig

def create: Unit

def createColumnGroupConstraintsAndIndexes: Unit

def dbType(declaration: String): DBType

def ddl: String

def declare[B](a: BaseColumnAttributeAssignment*): Seq[BaseColumnAttributeAssignment]

def defaultColumnAttributesForKeyedEntityId(typeOfIdField: Class[_]): Set[_ >: PrimaryKey <: AttributeValidOnNumericalColumn with Product with Serializable]

def defaultLengthOfString: Int

def defaultSizeOfBigDecimal: (Int, Int)

def drop: Unit

def endTransaction: Unit

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def execute(sql: String, logging: Boolean = true): Unit

def factoryFor[A](table: Table[A]): PosoFactoryPercursorTable[A]

implicit val fieldMapper: FieldMapper

def findAllTablesFor[A](c: Class[A]): Iterable[Table[_]]

def findTablesFor[A](a: A): Iterable[Table[A]]

def foreignKeyFromClass(c: Class[_]): String

final def getClass(): Class[_]

def getTable[T](name: String): dsl.Table[T]

def hashCode(): Int

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

def indexed(indexName: String): Indexed

def indexed: Indexed

def initialize: Unit

def initialize(config: Map[String, Any]): Unit

load configuration and then setup database and session

final def isInstanceOf[T0]: Boolean

def loadConfig(c: Map[String, Any]): ActiveRecordConfig

def name: Option[String]

def named(name: String): Named

final def ne(arg0: AnyRef): Boolean

def newSession: AbstractSession

final def notify(): Unit

final def notifyAll(): Unit

def on[A](table: Table[A])(declarations: (A) ⇒ Seq[BaseColumnAttributeAssignment]): Unit

def onDelete: ReferentialEvent

def onUpdate: ReferentialEvent

lazy val parentTypes: (scala.reflect.api.JavaUniverse.Type, scala.reflect.api.JavaUniverse.Symbol)

def primaryKey: PrimaryKey

def printDdl(statementHandler: (String) ⇒ Unit): Unit

def printDdl(pw: PrintWriter): Unit

def printDdl: Unit

def reset: Unit

drop and create table

def rollback: Unit

Rollback to startTransaction point

val sessionManager: SessionManager

def startTransaction: Unit

Set rollback point for test

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

def table[T <: AR](name: String)(implicit m: Manifest[T]): dsl.Table[T]

def table[T <: AR]()(implicit m: Manifest[T]): dsl.Table[T]

def table[T](name: String)(implicit manifestT: Manifest[T], ked: OptionalKeyedEntityDef[T, _]): Table[T]

def table[T](name: String, prefix: String)(implicit manifestT: Manifest[T], ked: OptionalKeyedEntityDef[T, _]): Table[T]

def table[T]()(implicit manifestT: Manifest[T], ked: OptionalKeyedEntityDef[T, _]): Table[T]

lazy val tableMap: Map[String, Table[_ >: IntermediateRecord <: AR]]

def tableNameFromClass(className: String): String

def tableNameFromClass(c: Class[_]): String

def tableNameFromClassName(tableName: String): String

def tableNameFromClasses(c1: Class[_], c2: Class[_]): String

def tables: Seq[Table[_]]

implicit def thisSchema: Schema

def toString(): String

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

def transient: IsTransient

def uninsertable: Uninsertable

def unique: Unique

def unupdatable: Unupdatable

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

final def wait(arg0: Long): Unit

final def wait(): Unit

def withRollback[T](f: ⇒ T): T

def finalize(): Unit