PolymorphicORMTable

abstract def caseClasses: Vector[Class[_ <: T]]

abstract def typeColumn: Column[Int]

final def !=(arg0: Any): Boolean

final def ##(): Int

def *: List[Column[_]]

final def ==(arg0: Any): Boolean

def addColumn[T](column: Column[T]): ListBuffer[Column[_]]

def addForeignColumn[T](column: Column[T]): ListBuffer[Column[_]]

def as(alias: String): TableAlias

final def asInstanceOf[T0]: T0

lazy val autoIncrement: Option[Column[_]]

implicit def bigDecimalConverter: BigDecimalDataType.type

implicit def blobConverter: BlobDataType.type

implicit def booleanConverter: BooleanDataType.type

def byId(primaryKey: Any): Option[T]

Retrieves an instance by id.

implicit def byteArrayConverter: ByteArrayDataType.type

def cached(key: Any): Option[T]

def caseClassForRow(result: QueryResult): EnhancedClass

Determines the class representation for the supplied QueryResult row.

lazy val clazz: EnhancedClass

def clearCached(key: Any): Unit

def clone(): AnyRef

def column[T](name: String, converter: DataType[T], properties: ColumnProperty*)(implicit manifest: Manifest[T]): Column[T]

def column[T](name: String, properties: ColumnProperty*)(implicit converter: DataType[T], manifest: Manifest[T]): Column[T]

def columns: List[Column[_]]

def columnsByName[T](names: String*): Seq[Column[T]]

val datastore: Datastore

def delete(t: T): Boolean

Deletes the supplied instance.

val deleted: UnitProcessor[T]

Fired immediately after successful delete.

val deleting: ModifiableOptionProcessor[T]

Fired immediately before deleting an object from the database.

implicit def doubleConverter: DoubleDataType.type

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

lazy val foreignKeys: List[Column[_]]

def get[P <: TableProperty](propertyName: String): Option[P]

final def getClass(): Class[_]

def getColumn[T](name: String): Option[Column[T]]

def has(propertyName: String): Boolean

def has(property: TableProperty): Boolean

def hasFieldsForThisTable(result: QueryResult): Boolean

def hasId(instance: T): Boolean

True if the supplied instance has an id assigned (meaning it has been persisted).

def hashCode(): Int

def idFor[C](instance: T): Option[ColumnValue[C]]

Returns an optional ColumnValue[C] for the supplied instance based on whether it has been persisted.

final def insert(t: T): T

Inserts the supplied instance into the datastore.

val inserted: UnitProcessor[T]

Fired immediate after successful insert.

val inserting: ModifiableProcessor[T]

Fired immediately before inserting a new object into the database.

implicit def intConverter: IntDataType.type

final def isInstanceOf[T0]: Boolean

implicit def javaDoubleConverter: JavaDoubleDataType.type

implicit def javaIntConverter: JavaIntDataType.type

implicit def javaLongConverter: JavaLongDataType.type

implicit def listString2StringConverter: ListStringConverter.type

def listen[Event, Response, Result](name: String, priority: Priority, modes: ListenMode*)(f: (Event) ⇒ Response)(implicit eventManifest: Manifest[Event]): FunctionalListener[Event, Response]

val listeners: Listeners

implicit def longConverter: LongDataType.type

implicit val manifest: Manifest[T]

lazy val many2Many: List[Column[_]]

lazy val many2One: List[Column[_]]

final def merge(t: T): T

Merges the instance into the database.

val merged: UnitProcessor[T]

Fired immediate after successful merge.

val merging: ModifiableProcessor[T]

Fired immediately before merging a new object into the database.

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def object2Row(instance: T, onlyChanges: Boolean): MappedObject[T]

Converts the supplied object to a MappedObject representing the modified object (during persistence) along with the column values to send to the database.

lazy val one2Many: List[Column[_]]

lazy val one2One: List[Column[_]]

implicit val optionDouble2DoubleConverter: Option2ValueConverter[Double]

implicit val optionDouble2JavaDoubleConverter: ConvertingOption2ValueConverter[Double, Double]

implicit val optionInt2IntConverter: Option2ValueConverter[Int]

implicit val optionInt2JavaIntConverter: ConvertingOption2ValueConverter[Integer, Int]

implicit val optionLong2JavaLongConverter: ConvertingOption2ValueConverter[Long, Long]

implicit val optionLong2LongConverter: Option2ValueConverter[Long]

implicit val optionString2StringConverter: Option2ValueConverter[String]

def orm[C](name: String, columnConverter: DataType[C], properties: ColumnProperty*)(implicit manifest: Manifest[C]): Column[C]

def orm[C](columnName: String, fieldName: String, properties: ColumnProperty*)(implicit columnConverter: DataType[C], manifest: Manifest[C]): Column[C]

def orm[C](name: String, properties: ColumnProperty*)(implicit columnConverter: DataType[C], manifest: Manifest[C]): Column[C]

def orm[C, F](columnName: String, fieldName: String, ormConverter: ORMConverter[C, F], properties: ColumnProperty*)(implicit columnConverter: DataType[C], columnManifest: Manifest[C], fieldManifest: Manifest[F]): Column[C]

def orm[C, F](columnName: String, fieldName: String, properties: ColumnProperty*)(implicit columnConverter: DataType[C], ormConverter: ORMConverter[C, F], columnManifest: Manifest[C], fieldManifest: Manifest[F]): Column[C]

def orm[C, F](name: String, columnConverter: DataType[C], ormConverter: ORMConverter[C, F], properties: ColumnProperty*)(implicit columnManifest: Manifest[C], fieldManifest: Manifest[F]): Column[C]

def orm[C, F](name: String, columnConverter: DataType[C], properties: ColumnProperty*)(implicit ormConverter: ORMConverter[C, F], columnManifest: Manifest[C], fieldManifest: Manifest[F]): Column[C]

def orm[C, F](name: String, properties: ColumnProperty*)(implicit columnConverter: DataType[C], ormConverter: ORMConverter[C, F], columnManifest: Manifest[C], fieldManifest: Manifest[F]): Column[C]

def orm[C, F](columnName: String, fieldName: String, columnConverter: DataType[C], ormConverter: ORMConverter[C, F], properties: ColumnProperty*)(implicit columnManifest: Manifest[C], fieldManifest: Manifest[F]): Column[C]

def ormColumns: List[ORMColumn[T, _, _]]

def persist(t: T): T

Inserts or updates the supplied instance based on whether an id is assigned to the instance.

val persistFailing: OptionProcessor[(T, Throwable), T]

Fired if an exception is thrown during persistence (insert, update, or merge).

val persisted: ModifiableProcessor[T]

Fired immediate after successful persisting.

def persistenceFor(caseClass: EnhancedClass): ORMPersistence[T]

val persisting: ModifiableProcessor[T]

Fired immediately before persisting an object to the database.

lazy val primaryKeys: List[Column[_]]

def primaryKeysFor(instance: T): List[ColumnValue[_]]

Retrieves a list of ColumnValue entries representing the primary keys for this table and their values based upon the supplied instance.

def prop[P <: TableProperty](propertyName: String): P

def properties: Iterable[TableProperty]

def props(properties: TableProperty*): Table

lazy val q: Query

Generates a query that will pull back all necessary fields and joins to represent the instance.

val queried: ModifiableProcessor[T]

Fired immediately after querying an instance.

def query(query: Query = q): ORMResultsIterator[T]

Queries the datastore for results based upon the supplied query.

def result2Object(result: QueryResult): T

Responsible method for converting a QueryResult into an instance of T.

implicit def stringConverter: StringDataType.type

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

lazy val tableName: String

implicit val thisListenable: Listenable

implicit def thisTable: Table

implicit val timestamp2LongConverter: Timestamp2Long.type

implicit def timestampConverter: TimestampDataType.type

def toString(): String

final def update(t: T): T

Updates the provided instance to the database.

def updateCached(key: Any, instance: T): Unit

def updateWithId(t: T, id: Int): T

Updates the supplied instance with a new id and returns the updated instance.

val updated: UnitProcessor[T]

Fired immediately after successful update.

val updating: ModifiableProcessor[T]

Fired immediately before updating an object in the database.

final def wait(): Unit

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

final def wait(arg0: Long): Unit

implicit def wrappedStringConverter: WrappedStringDataType.type