MappedTable

abstract def object2Row(value: T, onlyChanges: Boolean = true): 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.

abstract def primaryKeysFor(value: T): List[ColumnValue[_]]

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

abstract def q: Query

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

abstract def result2Object(result: QueryResult): T

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

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

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

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def *: List[Column[_]]

final def ==(arg0: AnyRef): Boolean

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: BigDecimalConverter.type

implicit def blobConverter: BlobConverter.type

implicit def booleanConverter: BooleanConverter.type

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

Retrieves an instance by id.

implicit def byteArrayConverter: ByteArrayConverter.type

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

lazy val clazz: EnhancedClass

def clearCached(key: Any): Unit

def clone(): AnyRef

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

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

def columns: List[Column[_]]

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

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: DoubleConverter.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 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.

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: IntConverter.type

final def isInstanceOf[T0]: Boolean

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: LongConverter.type

implicit val manifest: Manifest[T]

lazy val many2Many: List[Column[_]]

lazy val many2One: List[Column[_]]

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

lazy val one2Many: List[Column[_]]

lazy val one2One: List[Column[_]]

def persist(t: T): T

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

val persisted: ModifiableProcessor[T]

Fired immediate after successful persisting.

val persisting: ModifiableProcessor[T]

Fired immediately before persisting an object to the database.

lazy val primaryKeys: List[Column[_]]

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

def properties: Iterable[TableProperty]

def props(properties: TableProperty*): Table

val queried: ModifiableProcessor[T]

Fired immediately after querying an instance.

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

Queries the datastore for results based upon the supplied query.

implicit def stringConverter: StringConverter.type

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

lazy val tableName: String

implicit val thisListenable: Listenable

implicit def thisTable: Table

implicit def timestampConverter: TimestampConverter.type

def toString(): String

def update(t: T): T

Updates the provided instance to the database.

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

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: WrappedStringConverter.type