abstract
class
Molecule9[A, B, C, D, E, F, G, H, I] extends Molecule
Instance Constructors
-
new
Molecule9(_model: Model, _query: Query)
Type Members
-
case class
AsOf(tx: TxType) extends DbOp with Product with Serializable
-
sealed
trait
DbOp extends AnyRef
-
case class
Imagine(tx: List[AnyRef]) extends DbOp with Product with Serializable
-
type
KeepQueryOpsWhenFormatting = Int
-
case class
Since(date: Date) extends DbOp with Product with Serializable
-
sealed
trait
TxType extends AnyRef
-
type
lObj = List[AnyRef]
-
case class
txDate(txInstant: Date) extends TxType with Product with Serializable
-
case class
txLong(t: Long) extends TxType with Product with Serializable
-
case class
txlObj(tx: List[AnyRef]) extends TxType with Product with Serializable
Abstract Value Members
-
abstract
def
debug(implicit conn: Connection): Unit
-
abstract
def
get(implicit conn: Connection): Seq[(A, B, C, D, E, F, G, H, I)]
-
abstract
def
hl(implicit conn: Connection): Seq[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, HNil]]]]]]]]]]
Concrete Value Members
-
final
def
!=(arg0: Any): Boolean
-
final
def
##(): Int
-
final
def
==(arg0: Any): Boolean
-
object
History extends DbOp with Product with Serializable
-
val
_model: Model
-
val
_query: Query
-
def
add(implicit conn: Connection): Tx
-
final
def
asInstanceOf[T0]: T0
-
def
asOf(tx: lObj): Molecule9[A, B, C, D, E, F, G, H, I]
-
def
asOf(l: Long): Molecule9[A, B, C, D, E, F, G, H, I]
-
def
asOf(d: Date): Molecule9[A, B, C, D, E, F, G, H, I]
-
def
asOf_[M <: Molecule](thisMolecule: M, t: lObj): M
-
def
asOf_[M <: Molecule](thisMolecule: M, l: Long): M
-
def
asOf_[M <: Molecule](thisMolecule: M, d: Date): M
-
def
clone(): AnyRef
-
def
entityIds(query: Query)(implicit conn: Connection): List[Long]
-
final
def
eq(arg0: AnyRef): Boolean
-
def
equals(arg0: Any): Boolean
-
def
finalize(): Unit
-
def
get(n: Int)(implicit conn: Connection): Seq[(A, B, C, D, E, F, G, H, I)]
-
final
def
getClass(): Class[_]
-
def
getValues1(db: Database, id: Any, attr: String): Iterable[AnyRef]
-
def
hashCode(): Int
-
def
history: Molecule9[A, B, C, D, E, F, G, H, I]
-
def
history_[M <: Molecule](thisMolecule: M): M
-
def
hl(n: Int)(implicit conn: Connection): Seq[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, HNil]]]]]]]]]]
-
def
imagine(tx: lObj): Molecule9[A, B, C, D, E, F, G, H, I]
-
def
imagine_[M <: Molecule](thisMolecule: M, tx: lObj): M
-
def
inputs(query: Query): Seq[Any]
-
def
insert(conn: Connection, model: Model, dataRows: Seq[Seq[Any]] = Seq()): Tx
-
-
final
def
isInstanceOf[T0]: Boolean
-
def
load(tx: List[_], identifier: String = "", protocol: String = "mem"): Connection
-
final
def
ne(arg0: AnyRef): Boolean
-
final
def
notify(): Unit
-
final
def
notifyAll(): Unit
-
def
one(implicit conn: Connection): (A, B, C, D, E, F, G, H, I)
-
def
results(query: Query, conn: Connection): Collection[List[AnyRef]]
-
def
rule(query: Query): String
-
def
save(conn: Connection, model: Model): Tx
-
def
since(d: Date): Molecule9[A, B, C, D, E, F, G, H, I]
-
def
since_[M <: Molecule](thisMolecule: M, date: Date): M
-
def
some(implicit conn: Connection): Option[(A, B, C, D, E, F, G, H, I)]
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
-
def
toString(): String
-
def
update(implicit conn: Connection): Tx
-
def
update(conn: Connection, model: Model): Tx
-
final
def
wait(): Unit
-
final
def
wait(arg0: Long, arg1: Int): Unit
-
final
def
wait(arg0: Long): Unit
Inherited from AnyRef
Inherited from Any
