abstract
class
Molecule18[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R] extends Molecule
Instance Constructors
-
new
Molecule18(_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
-
type
Op[T] = Option[T]
-
case class
Since(date: Date) extends DbOp with Product with Serializable
-
sealed
trait
TxType extends AnyRef
-
type
W[Out] = ValueAttr[_, _, _, Out]
-
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
debugE(implicit conn: Connection): Unit
-
abstract
def
get(implicit conn: Connection): Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)]
-
abstract
def
getE(implicit conn: Connection): Seq[(Long, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)]
-
abstract
def
hl(implicit conn: Connection): Seq[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, ::[P, ::[Q, ::[R, 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): Molecule18[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R]
-
def
asOf(l: Long): Molecule18[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R]
-
def
asOf(d: Date): Molecule18[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R]
-
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
cast(a: Any): AnyRef
-
def
clone(): AnyRef
-
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, J, K, L, M, N, O, P, Q, R)]
-
final
def
getClass(): Class[_]
-
def
hashCode(): Int
-
def
history: Molecule18[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R]
-
def
history_[M <: Molecule](thisMolecule: M): M
-
def
hl(n: Int)(implicit conn: Connection): Seq[::[A, ::[B, ::[C, ::[D, ::[E, ::[F, ::[G, ::[H, ::[I, ::[J, ::[K, ::[L, ::[M, ::[N, ::[O, ::[P, ::[Q, ::[R, HNil]]]]]]]]]]]]]]]]]]]
-
def
imagine(tx: lObj): Molecule18[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R]
-
def
imagine_[M <: Molecule](thisMolecule: M, tx: lObj): M
-
def
inputs(query: Query): Seq[AnyRef]
-
def
insert(conn: Connection, model: Model, dataRows: Seq[Seq[Any]] = Seq()): Tx
-
-
final
def
isInstanceOf[T0]: Boolean
-
def
load(tx: Transaction, identifier: String = "", protocol: String = "mem"): Connection
-
def
loadList(txlist: List[_], identifier: String = "", protocol: String = "mem"): Connection
-
def
maybe[T1, T2, T3, T4](v1: W[T1], v2: W[T2], v3: W[T3], v4: W[T4])(implicit conn: Connection): Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, Op[T1], Op[T2], Op[T3], Op[T4])]
-
def
maybe[T1, T2, T3](v1: W[T1], v2: W[T2], v3: W[T3])(implicit conn: Connection): Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, Op[T1], Op[T2], Op[T3])]
-
def
maybe[T1, T2](v1: W[T1], v2: W[T2])(implicit conn: Connection): Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, Op[T1], Op[T2])]
-
def
maybe[T1](v1: W[T1])(implicit conn: Connection): Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, Op[T1])]
-
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, J, K, L, M, N, O, P, Q, R)
-
def
results(conn: Connection, model: Model, query: Query): Seq[List[AnyRef]]
-
def
save(conn: Connection, model: Model): Tx
-
def
since(d: Date): Molecule18[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R]
-
def
since_[M <: Molecule](thisMolecule: M, date: Date): M
-
def
some(implicit conn: Connection): Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)]
-
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
