ORMTable

Instance Constructors

new ORMTable(datastore: Datastore, tableProperties: TableProperty*)(implicit manifest: Manifest[T])
new ORMTable(datastore: Datastore, name: String, tableProperties: TableProperty*)(implicit manifest: Manifest[T])

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
def *: List[Column[_]]

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

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

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

Attributes
protected[com.outr.query]
Definition Classes
Table
def addForeignColumn[T](column: Column[T]): ListBuffer[Column[_]]

Attributes
protected[com.outr.query]
Definition Classes
Table
def as(alias: String): TableAlias

Definition Classes
Table
final def asInstanceOf[T0]: T0

Definition Classes
Any
lazy val autoIncrement: Option[Column[_]]

Definition Classes
Table
implicit def bigDecimalConverter: BigDecimalConverter.type

Definition Classes
Table
implicit def blobConverter: BlobConverter.type

Definition Classes
Table
implicit def booleanConverter: BooleanConverter.type

Definition Classes
Table
def byId(primaryKey: Any): Option[T]

Retrieves an instance by id.
Retrieves an instance by id.
primaryKey
the primary key to look up the instance
returns
Option[T]

Definition Classes
MappedTable
implicit def byteArrayConverter: ByteArrayConverter.type

Definition Classes
Table
def cached(key: Any): Option[T]

Definition Classes
MappedTable
def caseClassForRow(result: QueryResult): EnhancedClass

Determines the class representation for the supplied QueryResult row.
Determines the class representation for the supplied QueryResult row. Overriding this allows for polymorphism to function properly on this table. Defaults to using table's type.
result
the class representation for this row
returns
EnhancedClass
lazy val clazz: EnhancedClass

Definition Classes
MappedTable
def clearCached(key: Any): Unit

Definition Classes
MappedTable
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def column[T](name: String, converter: ColumnConverter[T], properties: ColumnProperty*)(implicit manifest: Manifest[T]): Column[T]

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

Definition Classes
Table
def columns: List[Column[_]]

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

Definition Classes
Table
def delete(t: T): Boolean

Deletes the supplied instance.
Deletes the supplied instance.
t
the instance to delete
returns
true if the delete was successful - will only be false if "deleting" event processor returns None

Definition Classes
MappedTable
val deleted: UnitProcessor[T]

Fired immediately after successful delete.
Fired immediately after successful delete.

Definition Classes
MappedTable
val deleting: ModifiableOptionProcessor[T]

Fired immediately before deleting an object from the database.
Fired immediately before deleting an object from the database. The instance may be modified or None returned to avoid deletion.

Definition Classes
MappedTable
implicit def doubleConverter: DoubleConverter.type

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

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
lazy val foreignKeys: List[Column[_]]

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

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

Definition Classes
AnyRef → Any
def getColumn[T](name: String): Option[Column[T]]

Definition Classes
Table
def has(propertyName: String): Boolean

Definition Classes
Table
def has(property: TableProperty): Boolean

Definition Classes
Table
def hasFieldsForThisTable(result: QueryResult): Boolean

Attributes
protected
def hasId(instance: T): Boolean

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

Definition Classes
MappedTable
def hashCode(): Int

Definition Classes
AnyRef → Any
def idFor[C](instance: T): Option[ColumnValue[C]]

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

Definition Classes
MappedTable
def insert(t: T): T

Inserts the supplied instance into the datastore.
Inserts the supplied instance into the datastore.
t
the instance to insert
returns
updated instance reflecting any changes resulting from the insert

Definition Classes
MappedTable
val inserted: UnitProcessor[T]

Fired immediate after successful insert.
Fired immediate after successful insert.

Definition Classes
MappedTable
val inserting: ModifiableProcessor[T]

Fired immediately before inserting a new object into the database.
Fired immediately before inserting a new object into the database. The instance may be modified in the response.

Definition Classes
MappedTable
implicit def intConverter: IntConverter.type

Definition Classes
Table
final def isInstanceOf[T0]: Boolean

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

Definition Classes
Listenable
val listeners: Listeners

Definition Classes
Listenable
implicit def longConverter: LongConverter.type

Definition Classes
Table
lazy val many2Many: List[Column[_]]

Definition Classes
Table
lazy val many2One: List[Column[_]]

Definition Classes
Table
def merge(t: T): T

Merges the instance into the database.
Merges the instance into the database. If a row already exists matching the primary keys of the instance it will be replaced, otherwise the record will be inserted.
t
the instance to merge
returns
updated instance reflecting any changes resulting from the merge

Definition Classes
MappedTable
val merged: UnitProcessor[T]

Fired immediate after successful merge.
Fired immediate after successful merge.

Definition Classes
MappedTable
val merging: ModifiableProcessor[T]

Fired immediately before merging a new object into the database.
Fired immediately before merging a new object into the database. The instance may be modified in the response.

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

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
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.
Converts the supplied object to a MappedObject representing the modified object (during persistence) along with the column values to send to the database.
onlyChanges
true if only the changed values should be supplied
returns
MappedObject[T]

Definition Classes
ORMTable → MappedTable
lazy val one2Many: List[Column[_]]

Definition Classes
Table
lazy val one2One: List[Column[_]]

Definition Classes
Table
implicit val optionInt2IntConverter: Option2ValueConverter[Int]
def orm[C](name: String, columnConverter: ColumnConverter[C], properties: ColumnProperty*)(implicit manifest: Manifest[C]): Column[C]
def orm[C](columnName: String, fieldName: String, properties: ColumnProperty*)(implicit columnConverter: ColumnConverter[C], manifest: Manifest[C]): Column[C]
def orm[C](name: String, properties: ColumnProperty*)(implicit columnConverter: ColumnConverter[C], manifest: Manifest[C]): Column[C]
def orm[C, F](columnName: String, fieldName: String, ormConverter: ORMConverter[C, F], properties: ColumnProperty*)(implicit columnConverter: ColumnConverter[C], columnManifest: Manifest[C], fieldManifest: Manifest[F]): Column[C]
def orm[C, F](columnName: String, fieldName: String, properties: ColumnProperty*)(implicit columnConverter: ColumnConverter[C], ormConverter: ORMConverter[C, F], columnManifest: Manifest[C], fieldManifest: Manifest[F]): Column[C]
def orm[C, F](name: String, columnConverter: ColumnConverter[C], ormConverter: ORMConverter[C, F], properties: ColumnProperty*)(implicit columnManifest: Manifest[C], fieldManifest: Manifest[F]): Column[C]
def orm[C, F](name: String, columnConverter: ColumnConverter[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: ColumnConverter[C], ormConverter: ORMConverter[C, F], columnManifest: Manifest[C], fieldManifest: Manifest[F]): Column[C]
def orm[C, F](columnName: String, fieldName: String, columnConverter: ColumnConverter[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.
Inserts or updates the supplied instance based on whether an id is assigned to the instance.
t
the instance to persist
returns
updated instance reflecting any changes resulting from the persist

Definition Classes
MappedTable
val persisted: ModifiableProcessor[T]

Fired immediate after successful persisting.
Fired immediate after successful persisting. Persisted is called after insert, merge, and update.

Definition Classes
MappedTable
def persistenceFor(caseClass: EnhancedClass): ORMPersistence[T]

Attributes
protected
val persisting: ModifiableProcessor[T]

Fired immediately before persisting an object to the database.
Fired immediately before persisting an object to the database. The instance may be modified in the response. Persisting is called before insert, merge, and update.

Definition Classes
MappedTable
lazy val primaryKeys: List[Column[_]]

Definition Classes
Table
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.
Retrieves a list of ColumnValue entries representing the primary keys for this table and their values based upon the supplied instance.
returns
List of primary keys tied to columns

Definition Classes
ORMTable → MappedTable
def prop[P <: TableProperty](propertyName: String): P

Definition Classes
Table
def properties: Iterable[TableProperty]

Definition Classes
Table
def props(properties: TableProperty*): Table

Definition Classes
Table
lazy val q: Query

Definition Classes
ORMTable → MappedTable
val queried: ModifiableProcessor[T]

Fired immediately after querying an instance.
Fired immediately after querying an instance. Listeners have the ability to modify the resulting instance.

Definition Classes
MappedTable
def query(query: Query): ORMResultsIterator[T]

Queries the datastore for results based upon the supplied query.
Queries the datastore for results based upon the supplied query.
query
the query to utilize
returns
iterator to cycle through instances derived from query result rows

Definition Classes
MappedTable
def result2Object(result: QueryResult): T

Responsible method for converting a QueryResult into an instance of T.
Responsible method for converting a QueryResult into an instance of T.
result
representation of result as an object T
returns
T

Definition Classes
ORMTable → MappedTable
implicit def stringConverter: StringConverter.type

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

Definition Classes
AnyRef
lazy val tableName: String

Definition Classes
Table
implicit val thisListenable: Listenable

Definition Classes
Listenable
implicit def thisTable: Table

Definition Classes
Table
implicit val timestamp2LongConverter: Timestamp2Long.type
implicit def timestampConverter: TimestampConverter.type

Definition Classes
Table
def toString(): String

Definition Classes
Table → AnyRef → Any
def update(t: T): T

Updates the provided instance to the database.
Updates the provided instance to the database.
t
the instance to update
returns
updated instance reflecting any changes resulting from the update to the database

Definition Classes
MappedTable
def updateCached(key: Any, instance: T): Unit

Definition Classes
MappedTable
def updateWithId(t: T, id: Int): T

Updates the supplied instance with a new id and returns the updated instance.
Updates the supplied instance with a new id and returns the updated instance.
t
the instance to assign an id to
id
the id to be assigned
returns
a copy of the instance with the new id

Definition Classes
ORMTable → MappedTable
val updated: UnitProcessor[T]

Fired immediately after successful update.
Fired immediately after successful update.

Definition Classes
MappedTable
val updating: ModifiableProcessor[T]

Fired immediately before updating an object in the database.
Fired immediately before updating an object in the database. The instance may be modified in the response.

Definition Classes
MappedTable
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( ... )
implicit def wrappedStringConverter: WrappedStringConverter.type

Definition Classes
Table

abstract class ORMTable[T] extends MappedTable[T]

Instance Constructors

new ORMTable(datastore: Datastore, tableProperties: TableProperty*)(implicit manifest: Manifest[T])

new ORMTable(datastore: Datastore, name: String, tableProperties: TableProperty*)(implicit manifest: Manifest[T])

Value Members

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]

implicit def byteArrayConverter: ByteArrayConverter.type

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

def caseClassForRow(result: QueryResult): EnhancedClass

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

val deleted: UnitProcessor[T]

val deleting: ModifiableOptionProcessor[T]

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 hasFieldsForThisTable(result: QueryResult): Boolean

def hasId(instance: T): Boolean

def hashCode(): Int

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

def insert(t: T): T

val inserted: UnitProcessor[T]

val inserting: ModifiableProcessor[T]

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

lazy val many2Many: List[Column[_]]

lazy val many2One: List[Column[_]]

def merge(t: T): T

val merged: UnitProcessor[T]

val merging: ModifiableProcessor[T]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

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

lazy val one2Many: List[Column[_]]

lazy val one2One: List[Column[_]]

implicit val optionInt2IntConverter: Option2ValueConverter[Int]

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

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

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

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

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

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

def orm[C, F](name: String, columnConverter: ColumnConverter[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: ColumnConverter[C], ormConverter: ORMConverter[C, F], columnManifest: Manifest[C], fieldManifest: Manifest[F]): Column[C]

def orm[C, F](columnName: String, fieldName: String, columnConverter: ColumnConverter[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

val persisted: ModifiableProcessor[T]