Molecule 0.15.0 - molecule.action.Molecule.Molecule09

final def !=(arg0: Any): Boolean

Definition Classes: AnyRef → Any

final def ##(): Int

Definition Classes: AnyRef → Any

final def ==(arg0: Any): Boolean

Definition Classes: AnyRef → Any

def _debugInsert(conn: Conn, data: Iterable[Seq[Any]]): Unit

Attributes: protected
Definition Classes: ShowDebug

def _getInsertTx(conn: Conn, data: Iterable[Seq[Any]]): Seq[Seq[Statement]]

Attributes: protected
Definition Classes: Molecule

def _insert(conn: Conn, model: Model, dataRows: Iterable[Seq[Any]] = Seq()): TxReport

Attributes: protected
Definition Classes: Molecule

val _model: Model

Internal Model representation of molecule.

Internal Model representation of molecule.

Molecule transforms custom boilerplate DSL constructs to Datomic queries in 3 steps:

Custom DSL molecule --> Model --> Query --> Datomic query string

Definition Classes: Molecule09 → MoleculeBase

val _nestedQuery: Option[Query]

Internal optional Query representation of nested molecule with added entity search for each level.

Internal optional Query representation of nested molecule with added entity search for each level.

Molecule transforms custom boilerplate DSL constructs to Datomic queries in 3 steps:

Custom DSL molecule --> Model --> Query --> Datomic query string

Definition Classes: Molecule09 → MoleculeBase

val _query: Query

Internal Query representation of molecule.

Internal Query representation of molecule.

Molecule transforms custom boilerplate DSL constructs to Datomic queries in 3 steps:

Custom DSL molecule --> Model --> Query --> Datomic query string

Definition Classes: Molecule09 → MoleculeBase

final def asInstanceOf[T0]: T0

Definition Classes: Any

final def cast(value: Any): String

Attributes: protected
Definition Classes: Helpers

def castAggrLazySeq[T](row: List[_], i: Int): T

Attributes: protected
Definition Classes: CastHelpers

def castAggrLazySeqBigDecimal(row: List[_], i: Int): BigDecimal

Attributes: protected
Definition Classes: CastHelpers

def castAggrLazySeqBigInt(row: List[_], i: Int): BigInt

Attributes: protected
Definition Classes: CastHelpers

def castAggrLazySeqDouble(row: List[_], i: Int): Float

Attributes: protected
Definition Classes: CastHelpers

def castAggrLazySeqInt(row: List[_], i: Int): Int

Attributes: protected
Definition Classes: CastHelpers

def castAggrListHashSet[T](row: List[_], i: Int): List[T]

Attributes: protected
Definition Classes: CastHelpers

def castAggrListHashSetBigDecimal(row: List[_], i: Int): List[BigDecimal]

Attributes: protected
Definition Classes: CastHelpers

def castAggrListHashSetBigInt(row: List[_], i: Int): List[BigInt]

Attributes: protected
Definition Classes: CastHelpers

def castAggrListHashSetFloat(row: List[_], i: Int): List[Float]

Attributes: protected
Definition Classes: CastHelpers

def castAggrListHashSetInt(row: List[_], i: Int): List[Int]

Attributes: protected
Definition Classes: CastHelpers

def castAggrListLazySeq[T](row: List[_], i: Int): List[T]

Attributes: protected
Definition Classes: CastHelpers

def castAggrListLazySeqBigDecimal(row: List[_], i: Int): List[BigDecimal]

Attributes: protected
Definition Classes: CastHelpers

def castAggrListLazySeqBigInt(row: List[_], i: Int): List[BigInt]

Attributes: protected
Definition Classes: CastHelpers

def castAggrListLazySeqFloat(row: List[_], i: Int): List[Float]

Attributes: protected
Definition Classes: CastHelpers

def castAggrListLazySeqInt(row: List[_], i: Int): List[Int]

Attributes: protected
Definition Classes: CastHelpers

def castAggrListVector[T](row: List[_], i: Int): List[T]

Attributes: protected
Definition Classes: CastHelpers

def castAggrListVectorBigDecimal(row: List[_], i: Int): List[BigDecimal]

Attributes: protected
Definition Classes: CastHelpers

def castAggrListVectorBigInt(row: List[_], i: Int): List[BigInt]

Attributes: protected
Definition Classes: CastHelpers

def castAggrListVectorFloat(row: List[_], i: Int): List[Float]

Attributes: protected
Definition Classes: CastHelpers

def castAggrListVectorInt(row: List[_], i: Int): List[Int]

Attributes: protected
Definition Classes: CastHelpers

def castAggrVector[T](row: List[_], i: Int): T

Attributes: protected
Definition Classes: CastHelpers

def castAggrVectorBigDecimal(row: List[_], i: Int): BigDecimal

Attributes: protected
Definition Classes: CastHelpers

def castAggrVectorBigInt(row: List[_], i: Int): BigInt

Attributes: protected
Definition Classes: CastHelpers

def castAggrVectorDouble(row: List[_], i: Int): Float

Attributes: protected
Definition Classes: CastHelpers

def castAggrVectorInt(row: List[_], i: Int): Int

Attributes: protected
Definition Classes: CastHelpers

def castMany[T](row: List[_], i: Int): Set[T]

Attributes: protected
Definition Classes: CastHelpers

def castManyBigDecimal(row: List[_], i: Int): Set[BigDecimal]

Attributes: protected
Definition Classes: CastHelpers

def castManyBigInt(row: List[_], i: Int): Set[BigInt]

Attributes: protected
Definition Classes: CastHelpers

def castManyEnum(row: List[_], i: Int): Set[String]

Attributes: protected
Definition Classes: CastHelpers

def castManyFloat(row: List[_], i: Int): Set[Float]

Attributes: protected
Definition Classes: CastHelpers

def castManyInt(row: List[_], i: Int): Set[Int]

Attributes: protected
Definition Classes: CastHelpers

def castMapBigDecimal(row: List[_], i: Int): Map[String, BigDecimal]

Attributes: protected
Definition Classes: CastHelpers

def castMapBigInt(row: List[_], i: Int): Map[String, BigInt]

Attributes: protected
Definition Classes: CastHelpers

def castMapBoolean(row: List[_], i: Int): Map[String, Boolean]

Attributes: protected
Definition Classes: CastHelpers

def castMapDate(row: List[_], i: Int): Map[String, Date]

Attributes: protected
Definition Classes: CastHelpers

def castMapDouble(row: List[_], i: Int): Map[String, Double]

Attributes: protected
Definition Classes: CastHelpers

def castMapFloat(row: List[_], i: Int): Map[String, Float]

Attributes: protected
Definition Classes: CastHelpers

def castMapInt(row: List[_], i: Int): Map[String, Int]

Attributes: protected
Definition Classes: CastHelpers

def castMapLong(row: List[_], i: Int): Map[String, Long]

Attributes: protected
Definition Classes: CastHelpers

def castMapString(row: List[_], i: Int): Map[String, String]

Attributes: protected
Definition Classes: CastHelpers

def castMapURI(row: List[_], i: Int): Map[String, URI]

Attributes: protected
Definition Classes: CastHelpers

def castMapUUID(row: List[_], i: Int): Map[String, UUID]

Attributes: protected
Definition Classes: CastHelpers

def castOne[T](row: List[_], i: Int): T

Attributes: protected
Definition Classes: CastHelpers

def castOneBigDecimal(row: List[_], i: Int): BigDecimal

Attributes: protected
Definition Classes: CastHelpers

def castOneBigInt(row: List[_], i: Int): BigInt

Attributes: protected
Definition Classes: CastHelpers

def castOneFloat(row: List[_], i: Int): Float

Attributes: protected
Definition Classes: CastHelpers

def castOneInt(row: List[_], i: Int): Int

Attributes: protected
Definition Classes: CastHelpers

def castOptMany[T](row: List[_], i: Int): Option[Set[T]]

Attributes: protected
Definition Classes: CastHelpers

def castOptManyApply[T](row: List[_], i: Int): Option[Set[T]]

Attributes: protected
Definition Classes: CastHelpers

def castOptManyApplyBigDecimal(row: List[_], i: Int): Option[Set[BigDecimal]]

Attributes: protected
Definition Classes: CastHelpers

def castOptManyApplyBigInt(row: List[_], i: Int): Option[Set[BigInt]]

Attributes: protected
Definition Classes: CastHelpers

def castOptManyApplyDouble(row: List[_], i: Int): Option[Set[Double]]

Attributes: protected
Definition Classes: CastHelpers

def castOptManyApplyFloat(row: List[_], i: Int): Option[Set[Float]]

Attributes: protected
Definition Classes: CastHelpers

def castOptManyApplyInt(row: List[_], i: Int): Option[Set[Int]]

Attributes: protected
Definition Classes: CastHelpers

def castOptManyApplyLong(row: List[_], i: Int): Option[Set[Long]]

Attributes: protected
Definition Classes: CastHelpers

def castOptManyBigDecimal(row: List[_], i: Int): Option[Set[BigDecimal]]

Attributes: protected
Definition Classes: CastHelpers

def castOptManyBigInt(row: List[_], i: Int): Option[Set[BigInt]]

Attributes: protected
Definition Classes: CastHelpers

def castOptManyDouble(row: List[_], i: Int): Option[Set[Double]]

Attributes: protected
Definition Classes: CastHelpers

def castOptManyEnum(row: List[_], i: Int): Option[Set[String]]

Attributes: protected
Definition Classes: CastHelpers

def castOptManyFloat(row: List[_], i: Int): Option[Set[Float]]

Attributes: protected
Definition Classes: CastHelpers

def castOptManyInt(row: List[_], i: Int): Option[Set[Int]]

Attributes: protected
Definition Classes: CastHelpers

def castOptManyLong(row: List[_], i: Int): Option[Set[Long]]

Attributes: protected
Definition Classes: CastHelpers

def castOptManyRefAttr(row: List[_], i: Int): Option[Set[Long]]

Attributes: protected
Definition Classes: CastHelpers

def castOptMapApplyBigDecimal(row: List[_], i: Int): Option[Map[String, BigDecimal]]

Attributes: protected
Definition Classes: CastHelpers

def castOptMapApplyBigInt(row: List[_], i: Int): Option[Map[String, BigInt]]

Attributes: protected
Definition Classes: CastHelpers

def castOptMapApplyBoolean(row: List[_], i: Int): Option[Map[String, Boolean]]

Attributes: protected
Definition Classes: CastHelpers

def castOptMapApplyDate(row: List[_], i: Int): Option[Map[String, Date]]

Attributes: protected
Definition Classes: CastHelpers

def castOptMapApplyDouble(row: List[_], i: Int): Option[Map[String, Double]]

Attributes: protected
Definition Classes: CastHelpers

def castOptMapApplyFloat(row: List[_], i: Int): Option[Map[String, Float]]

Attributes: protected
Definition Classes: CastHelpers

def castOptMapApplyInt(row: List[_], i: Int): Option[Map[String, Int]]

Attributes: protected
Definition Classes: CastHelpers

def castOptMapApplyLong(row: List[_], i: Int): Option[Map[String, Long]]

Attributes: protected
Definition Classes: CastHelpers

def castOptMapApplyString(row: List[_], i: Int): Option[Map[String, String]]

Attributes: protected
Definition Classes: CastHelpers

def castOptMapApplyURI(row: List[_], i: Int): Option[Map[String, URI]]

Attributes: protected
Definition Classes: CastHelpers

def castOptMapApplyUUID(row: List[_], i: Int): Option[Map[String, UUID]]

Attributes: protected
Definition Classes: CastHelpers

def castOptMapBigDecimal(row: List[_], i: Int): Option[Map[String, BigDecimal]]

Attributes: protected
Definition Classes: CastHelpers

def castOptMapBigInt(row: List[_], i: Int): Option[Map[String, BigInt]]

Attributes: protected
Definition Classes: CastHelpers

def castOptMapBoolean(row: List[_], i: Int): Option[Map[String, Boolean]]

Attributes: protected
Definition Classes: CastHelpers

def castOptMapDate(row: List[_], i: Int): Option[Map[String, Date]]

Attributes: protected
Definition Classes: CastHelpers

def castOptMapDouble(row: List[_], i: Int): Option[Map[String, Double]]

Attributes: protected
Definition Classes: CastHelpers

def castOptMapFloat(row: List[_], i: Int): Option[Map[String, Float]]

Attributes: protected
Definition Classes: CastHelpers

def castOptMapInt(row: List[_], i: Int): Option[Map[String, Int]]

Attributes: protected
Definition Classes: CastHelpers

def castOptMapLong(row: List[_], i: Int): Option[Map[String, Long]]

Attributes: protected
Definition Classes: CastHelpers

def castOptMapString(row: List[_], i: Int): Option[Map[String, String]]

Attributes: protected
Definition Classes: CastHelpers

def castOptMapURI(row: List[_], i: Int): Option[Map[String, URI]]

Attributes: protected
Definition Classes: CastHelpers

def castOptMapUUID(row: List[_], i: Int): Option[Map[String, UUID]]

Attributes: protected
Definition Classes: CastHelpers

def castOptOne[T](row: List[_], i: Int): Option[T]

Attributes: protected
Definition Classes: CastHelpers

def castOptOneApply[T](row: List[_], i: Int): Option[T]

Attributes: protected
Definition Classes: CastHelpers

def castOptOneApplyBigDecimal(row: List[_], i: Int): Option[BigDecimal]

Attributes: protected
Definition Classes: CastHelpers

def castOptOneApplyBigInt(row: List[_], i: Int): Option[BigInt]

Attributes: protected
Definition Classes: CastHelpers

def castOptOneApplyDouble(row: List[_], i: Int): Option[Double]

Attributes: protected
Definition Classes: CastHelpers

def castOptOneApplyFloat(row: List[_], i: Int): Option[Float]

Attributes: protected
Definition Classes: CastHelpers

def castOptOneApplyInt(row: List[_], i: Int): Option[Int]

Attributes: protected
Definition Classes: CastHelpers

def castOptOneApplyLong(row: List[_], i: Int): Option[Long]

Attributes: protected
Definition Classes: CastHelpers

def castOptOneBigDecimal(row: List[_], i: Int): Option[BigDecimal]

Attributes: protected
Definition Classes: CastHelpers

def castOptOneBigInt(row: List[_], i: Int): Option[BigInt]

Attributes: protected
Definition Classes: CastHelpers

def castOptOneDouble(row: List[_], i: Int): Option[Double]

Attributes: protected
Definition Classes: CastHelpers

def castOptOneEnum(row: List[_], i: Int): Option[String]

Attributes: protected
Definition Classes: CastHelpers

def castOptOneFloat(row: List[_], i: Int): Option[Float]

Attributes: protected
Definition Classes: CastHelpers

def castOptOneInt(row: List[_], i: Int): Option[Int]

Attributes: protected
Definition Classes: CastHelpers

def castOptOneLong(row: List[_], i: Int): Option[Long]

Attributes: protected
Definition Classes: CastHelpers

def castOptOneRefAttr(row: List[_], i: Int): Option[Long]

Attributes: protected
Definition Classes: CastHelpers

def castRow(row: List[AnyRef]): (A, B, C, D, E, F, G, H, I)

Attributes: protected
Definition Classes: CastHelpers

def clone(): AnyRef

Attributes: protected[java.lang]
Definition Classes: AnyRef
Annotations: @native() @throws( ... )

final def date(s: String): Date

Attributes: protected
Definition Classes: Helpers

def debugGet(implicit conn: Conn): Unit

Debug call to get on a molecule (without affecting the db).

Debug call to get on a molecule (without affecting the db).

Prints the following to output:

1. Internal molecule transformation representations:
Molecule DSL --> Model --> Query --> Datomic query

2. Data returned from get query (max 500 rows).

conn: Implicit Conn value in scope

Definition Classes: ShowDebug

def debugGetAsOf(date: Date)(implicit conn: Conn): Unit

Debug call to getAsOf(date) on a molecule (without affecting the db).

Debug call to getAsOf(date) on a molecule (without affecting the db).

Prints the following to output:

1. Internal molecule transformation representations:
Molecule DSL --> Model --> Query --> Datomic query

2. Data returned from get query (max 500 rows).

conn: Implicit Conn value in scope

Definition Classes: ShowDebug

def debugGetAsOf(tx: TxReport)(implicit conn: Conn): Unit

Debug call to getAsOf(tx) on a molecule (without affecting the db).

Debug call to getAsOf(tx) on a molecule (without affecting the db).

Prints the following to output:

1. Internal molecule transformation representations:
Molecule DSL --> Model --> Query --> Datomic query

2. Data returned from get query (max 500 rows).

tx: TxReport
conn: Implicit Conn value in scope

Definition Classes: ShowDebug

def debugGetAsOf(t: Long)(implicit conn: Conn): Unit

Debug call to getAsOf(t) on a molecule (without affecting the db).

Debug call to getAsOf(t) on a molecule (without affecting the db).

Prints the following to output:

1. Internal molecule transformation representations:
Molecule DSL --> Model --> Query --> Datomic query

2. Data returned from get query (max 500 rows).

conn: Implicit Conn value in scope

Definition Classes: ShowDebug

def debugGetHistory(implicit conn: Conn): Unit

Debug call to getHistory on a molecule (without affecting the db).

Debug call to getHistory on a molecule (without affecting the db).

Prints the following to output:

1. Internal molecule transformation representations:
Molecule DSL --> Model --> Query --> Datomic query

2. Data returned from get query (max 500 rows).

conn: Implicit Conn value in scope

Definition Classes: ShowDebug

def debugGetSince(date: Date)(implicit conn: Conn): Unit

Debug call to getSince(date) on a molecule (without affecting the db).

Debug call to getSince(date) on a molecule (without affecting the db).

Prints the following to output:

1. Internal molecule transformation representations:
Molecule DSL --> Model --> Query --> Datomic query

2. Data returned from get query (max 500 rows).

conn: Implicit Conn value in scope

Definition Classes: ShowDebug

def debugGetSince(tx: TxReport)(implicit conn: Conn): Unit

Debug call to getSince(tx) on a molecule (without affecting the db).

Debug call to getSince(tx) on a molecule (without affecting the db).

Prints the following to output:

1. Internal molecule transformation representations:
Molecule DSL --> Model --> Query --> Datomic query

2. Data returned from get query (max 500 rows).

tx: TxReport
conn: Implicit Conn value in scope

Definition Classes: ShowDebug

def debugGetSince(t: Long)(implicit conn: Conn): Unit

Debug call to getSince(t) on a molecule (without affecting the db).

Debug call to getSince(t) on a molecule (without affecting the db).

Prints the following to output:

1. Internal molecule transformation representations:
Molecule DSL --> Model --> Query --> Datomic query

2. Data returned from get query (max 500 rows).

conn: Implicit Conn value in scope

Definition Classes: ShowDebug

def debugGetWith(txData: List[List[_]])(implicit conn: Conn): Unit

Debug call to getWith(txData) on a molecule (without affecting the db).

Debug call to getWith(txData) on a molecule (without affecting the db).

Prints the following to output:

1. Internal molecule transformation representations:
Molecule DSL --> Model --> Query --> Datomic query

2. Data returned from get query (max 500 rows).

3. Transactions of applied transaction data.

txData: Raw transaction data as java.util.List[Object]
conn: Implicit Conn value in scope

Definition Classes: ShowDebug

def debugGetWith(txMolecules: Seq[Seq[Statement]]*)(implicit conn: Conn): Unit

Debug call to getWith(txMolecules) on a molecule (without affecting the db).

Debug call to getWith(txMolecules) on a molecule (without affecting the db).

Prints the following to output:

1. Internal molecule transformation representations:
Molecule DSL --> Model --> Query --> Datomic query

2. Data returned from get query (max 500 rows).

3. Transactions of applied transaction molecules.

txMolecules: Transaction statements from applied Molecules with test data
conn: Implicit Conn value in scope

Definition Classes: ShowDebug

def debugSave(implicit conn: Conn): Unit

Debug call to save on a molecule (without affecting the db).

Debug call to save on a molecule (without affecting the db).

Prints internal molecule transformation representations to output:

Model --> Generic statements --> Datomic statements

conn: Implicit Conn value in scope
returns: Unit

Definition Classes: ShowDebug

def debugUpdate(implicit conn: Conn): Unit

Debug call to update on a molecule (without affecting the db).

Debug call to update on a molecule (without affecting the db).

Prints internal molecule transformation representations to output:

Model --> Generic statements --> Datomic statements

conn: Implicit Conn value in scope

Definition Classes: ShowDebug

final def eq(arg0: AnyRef): Boolean

Definition Classes: AnyRef

def equals(arg0: Any): Boolean

Definition Classes: AnyRef → Any

final def f(a: Any): Any

Attributes: protected
Definition Classes: Helpers

final def f2(a: Any): Any

Attributes: protected
Definition Classes: Helpers

def finalize(): Unit

Attributes: protected[java.lang]
Definition Classes: AnyRef
Annotations: @throws( classOf[java.lang.Throwable] )

final def format(date: Date): String

Attributes: protected
Definition Classes: Helpers

final def format2(date: Date): String

Attributes: protected
Definition Classes: Helpers

def get(n: Int)(implicit conn: Conn, ev: ClassTag[(A, B, C, D, E, F, G, H, I)]): List[(A, B, C, D, E, F, G, H, I)]

Get List of n rows as tuples matching molecule.

Get List of n rows as tuples matching molecule.

Only n rows are type-casted.

Person.name.age.get(1) === List(
  ("Ben", 42)
)

Since retrieving a List is considered the default fetch format, the getter method is simply named get (and not getList).

n: Int Number of rows returned
conn: Implicit Conn value in scope
returns: List[Tpl] where Tpl is a tuple of types matching the attributes of the molecule

Definition Classes: GetList

def get(implicit conn: Conn, ev: ClassTag[(A, B, C, D, E, F, G, H, I)]): List[(A, B, C, D, E, F, G, H, I)]

Get List of all rows as tuples matching molecule.

Person.name.age.get === List(
  ("Ben", 42),
  ("Liz", 37),
)

Since retrieving a List is considered the default fetch format, the getter method is simply named get (and not getList).

conn: Implicit Conn value in scope
returns: List[Tpl] where Tpl is a tuple of types matching the attributes of the molecule

Definition Classes: GetList

def getArray(n: Int)(implicit conn: Conn, ev: ClassTag[(A, B, C, D, E, F, G, H, I)]): Array[(A, B, C, D, E, F, G, H, I)]

Get Array of n rows as tuples matching molecule.

Person.name.age.getArray(1) === Array(
  ("Ben", 42)
)

Getting a pre-allocated Array populated with typed data is the fastest way to query Datomic with Molecule. Looping the Array in a while loop with a mutable index pointer will also be the fastest way to traverse the data set.

The Array is only populated with n rows of type-casted tuples.

n: Number of rows
conn: Implicit Conn value in scope
returns: Array[Tpl] where Tpl is a tuple of types matching the attributes of the molecule

Definition Classes: GetArray

def getArray(implicit conn: Conn, ev: ClassTag[(A, B, C, D, E, F, G, H, I)]): Array[(A, B, C, D, E, F, G, H, I)]

Get Array of all rows as tuples matching molecule.

Person.name.age.getArray === Array(
  ("Ben", 42),
  ("Liz", 37),
)

Getting a pre-allocated Array populated with typed data is the fastest way to query Datomic with Molecule. Looping the Array in a while loop with a mutable index pointer will also be the fastest way to traverse the data set.

conn: Implicit Conn value in scope
returns: Array[Tpl] where Tpl is a tuple of types matching the attributes of the molecule

Definition Classes: GetArray

def getArrayAsOf(date: Date, n: Int)(implicit conn: Conn, ev: ClassTag[(A, B, C, D, E, F, G, H, I)]): Array[(A, B, C, D, E, F, G, H, I)]

Get Array of n rows as tuples matching molecule as of date.

Get Array of n rows as tuples matching molecule as of date.

Get data at a human point in time (a java.util.Date).

val beforeInsert = new java.util.Date

// Insert
val tx1 = Person.name.age insert List(
  ("Ben", 42),
  ("Liz", 37)
)
val List(ben, liz) = tx1.eids
val afterInsert = new java.util.Date

// Update
val tx2 = Person(ben).age(43).update
val afterUpdate = new java.util.Date

// Get Array of all rows as of afterUpdate
Person.name.age.getArrayAsOf(afterUpdate) === Array(
  ("Ben", 43),
  ("Liz", 37)
)

// Get Array of n rows as of afterUpdate
Person.name.age.getArrayAsOf(afterUpdate, 1) === Array(
  ("Ben", 43)
)

Getting a pre-allocated Array populated with typed data is the fastest way to query Datomic with Molecule. Looping the Array in a while loop with a mutable index pointer will also be the fastest way to traverse the data set.

The Array is only populated with n rows of type-casted tuples.

date: java.util.Date
n: Int Number of rows returned
conn: Implicit Conn value in scope
returns: Array[Tpl] where Tpl is a tuple of data matching molecule

Definition Classes: GetArray
See also: Manual on getAsOf

def getArrayAsOf(date: Date)(implicit conn: Conn, ev: ClassTag[(A, B, C, D, E, F, G, H, I)]): Array[(A, B, C, D, E, F, G, H, I)]

Get Array of all rows as tuples matching molecule as of date.

Get Array of all rows as tuples matching molecule as of date.

Get data at a human point in time (a java.util.Date).

val beforeInsert = new java.util.Date

// Insert
val tx1 = Person.name.age insert List(
  ("Ben", 42),
  ("Liz", 37)
)
val List(ben, liz) = tx1.eids
val afterInsert = new java.util.Date

// Update
val tx2 = Person(ben).age(43).update
val afterUpdate = new java.util.Date

// Retract
val tx3 = ben.retract
val afterRetract = new java.util.Date

// No data yet before insert
Person.name.age.getArrayAsOf(beforeInsert) === Array()

// Get Array of all rows as of afterInsert
Person.name.age.getArrayAsOf(afterInsert) === Array(
  ("Ben", 42),
  ("Liz", 37)
)

// Get Array of all rows as of afterUpdate
Person.name.age.getArrayAsOf(afterUpdate) === Array(
  ("Ben", 43), // Ben now 43
  ("Liz", 37)
)

// Get Array of all rows as of afterRetract
Person.name.age.getArrayAsOf(afterRetract) === Array(
  ("Liz", 37) // Ben gone
)

Getting a pre-allocated Array populated with typed data is the fastest way to query Datomic with Molecule. Looping the Array in a while loop with a mutable index pointer will also be the fastest way to traverse the data set.

date: java.util.Date
conn: Implicit Conn value in scope
returns: Array[Tpl] where Tpl is a tuple of data matching molecule

Definition Classes: GetArray
See also: Manual on getAsOf

def getArrayAsOf(tx: TxReport, n: Int)(implicit conn: Conn, ev: ClassTag[(A, B, C, D, E, F, G, H, I)]): Array[(A, B, C, D, E, F, G, H, I)]

Get Array of n rows as tuples matching molecule as of tx.

Get Array of n rows as tuples matching molecule as of tx.

Datomic's internal asOf method can take a transaction entity id as argument to retrieve a database value as of that transaction (including).

Instead of supplying the transaction entity id, in Molecule we supply a TxReport that contains the transaction entity id (which is used as argument to Datomic internally). This is more convenient when using Molecule since we get a TxReport from transaction operations like get, update, retract etc.

// Insert (tx report 1)
val tx1 = Person.name.age insert List(
  ("Ben", 42),
  ("Liz", 37)
)
val List(ben, liz) = tx1.eids

// Update (tx report 2)
val tx2 = Person(ben).age(43).update

// Get Array of all rows as of tx2 (after update)
Person.name.age.getArrayAsOf(tx2) === Array(
  ("Ben", 43),
  ("Liz", 37)
)

// Get Array of n rows as of tx2 (after update)
Person.name.age.getArrayAsOf(tx2, 1) === Array(
  ("Ben", 43)
)

Getting a pre-allocated Array populated with typed data is the fastest way to query Datomic with Molecule. Looping the Array in a while loop with a mutable index pointer will also be the fastest way to traverse the data set.

The Array is only populated with n rows of type-casted tuples.

tx: TxReport (returned from all molecule transaction operations)
n: Int Number of rows returned
conn: Implicit Conn value in scope
returns: Array[Tpl] where Tpl is a tuple of data matching molecule

Definition Classes: GetArray
See also: Manual on getAsOf

def getArrayAsOf(tx: TxReport)(implicit conn: Conn, ev: ClassTag[(A, B, C, D, E, F, G, H, I)]): Array[(A, B, C, D, E, F, G, H, I)]

Get Array of all rows as tuples matching molecule as of tx.

Get Array of all rows as tuples matching molecule as of tx.

Datomic's internal asOf method can take a transaction entity id as argument to retrieve a database value as of that transaction (including).

Instead of supplying the transaction entity id, in Molecule we supply a TxReport that contains the transaction entity id (which is used as argument to Datomic internally). This is more convenient when using Molecule since we get a TxReport from transaction operations like get, update, retract etc.

// Insert (tx report 1)
val tx1 = Person.name.age insert List(
  ("Ben", 42),
  ("Liz", 37)
)
val List(ben, liz) = tx1.eids

// Update (tx report 2)
val tx2 = Person(ben).age(43).update

// Retract (tx report 3)
val tx3 = ben.retract

// Get Array of all rows as of tx1 (after insert)
Person.name.age.getArrayAsOf(tx1) === Array(
  ("Ben", 42),
  ("Liz", 37)
)

// Get Array of all rows as of tx2 (after update)
Person.name.age.getArrayAsOf(tx2) === Array(
  ("Ben", 43), // Ben now 43
  ("Liz", 37)
)

// Get Array of all rows as of tx3 (after retract)
Person.name.age.getArrayAsOf(tx3) === Array(
  ("Liz", 37) // Ben gone
)

Getting a pre-allocated Array populated with typed data is the fastest way to query Datomic with Molecule. Looping the Array in a while loop with a mutable index pointer will also be the fastest way to traverse the data set.

tx: TxReport (returned from all molecule transaction operations)
conn: Implicit Conn value in scope
returns: Array[Tpl] where Tpl is a tuple of data matching molecule

Definition Classes: GetArray
See also: Manual on getAsOf

def getArrayAsOf(t: Long, n: Int)(implicit conn: Conn, ev: ClassTag[(A, B, C, D, E, F, G, H, I)]): Array[(A, B, C, D, E, F, G, H, I)]

Get Array of n rows as tuples matching molecule as of transaction time t.

Get Array of n rows as tuples matching molecule as of transaction time t.

Transaction time t is an auto-incremented transaction number assigned internally by Datomic.

t can for instance be retrieved in a getHistory call for an attribute and then be used to get data as of that point in time (including that transaction):

// Insert (t 1028)
val List(ben, liz) = Person.name.age insert List(
  ("Ben", 42),
  ("Liz", 37)
) eids

// Update (t 1031)
Person(ben).age(43).update

// History of Ben
Person(ben).age.t.op.getHistory.sortBy(r => (r._2, r._3)) === List(
  (42, 1028, true),  // Insert:  42 asserted
  (42, 1031, false), // Update:  42 retracted
  (43, 1031, true),  //          43 asserted
)

// Get Array of all rows as of transaction t 1031 (after update)
Person.name.age.getArrayAsOf(1031) === Array(
  ("Ben", 43),
  ("Liz", 37)
)

// Get Array of n rows as of transaction t 1031 (after update)
Person.name.age.getArrayAsOf(1031, 1) === Array(
  ("Ben", 43)
)

Getting a pre-allocated Array populated with typed data is the fastest way to query Datomic with Molecule. Looping the Array in a while loop with a mutable index pointer will also be the fastest way to traverse the data set.

The Array is only populated with n rows of type-casted tuples.

t: Long Transaction time t
n: Int Number of rows returned
conn: Implicit Conn value in scope
returns: Array[Tpl] where Tpl is a tuple of data matching molecule

Definition Classes: GetArray
See also: Manual on getAsOf

def getArrayAsOf(t: Long)(implicit conn: Conn, ev: ClassTag[(A, B, C, D, E, F, G, H, I)]): Array[(A, B, C, D, E, F, G, H, I)]

Get Array of all rows as tuples matching molecule as of transaction time t.

Get Array of all rows as tuples matching molecule as of transaction time t.

Transaction time t is an auto-incremented transaction number assigned internally by Datomic.

t can for instance be retrieved in a getHistory call for an attribute and then be used to get data as of that point in time (including that transaction):

// Insert (t 1028)
val List(ben, liz) = Person.name.age insert List(
  ("Ben", 42),
  ("Liz", 37)
) eids

// Update (t 1031)
Person(ben).age(43).update

// Retract (t 1032)
ben.retract

// History of Ben
Person(ben).age.t.op.getHistory.sortBy(r => (r._2, r._3)) === List(
  (42, 1028, true),  // Insert:  42 asserted
  (42, 1031, false), // Update:  42 retracted
  (43, 1031, true),  //          43 asserted
  (43, 1032, false)  // Retract: 43 retracted
)

// Get Array of data as of transaction t 1028 (after insert)
Person.name.age.getArrayAsOf(1028) === Array(
  ("Ben", 42),
  ("Liz", 37)
)

// Get Array of all rows as of transaction t 1031 (after update)
Person.name.age.getArrayAsOf(1031) === Array(
  ("Ben", 43),
  ("Liz", 37)
)

// Get Array of all rows as of transaction t 1032 (after retract)
Person.name.age.getArrayAsOf(1032) === Array(
  ("Liz", 37)
)

Getting a pre-allocated Array populated with typed data is the fastest way to query Datomic with Molecule. Looping the Array in a while loop with a mutable index pointer will also be the fastest way to traverse the data set.

t: Transaction time t
conn: Implicit Conn value in scope
returns: Array[Tpl] where Tpl is a tuple of data matching molecule

Definition Classes: GetArray
See also: Manual on getAsOf

def getArraySince(date: Date, n: Int)(implicit conn: Conn, ev: ClassTag[(A, B, C, D, E, F, G, H, I)]): Array[(A, B, C, D, E, F, G, H, I)]

Get Array of n rows as tuples matching molecule since date.

Get Array of n rows as tuples matching molecule since date.

Get data added/retracted since a human point in time (a java.util.Date).

// Transact 3 times (`inst` retrieves transaction time/Date from tx report)
val date1 = Person.name("Ann").save.inst
val date2 = Person.name("Ben").save.inst
val date3 = Person.name("Cay").save.inst

// Current values
Person.name.get === List("Ann", "Ben", "Cay")

// Ben and Cay added since date1
Person.name.getArraySince(date1) === Array("Ben", "Cay")

// Ben and Cay added since date1 - only n (1) rows returned
Person.name.getArraySince(date1, 1) === Array("Ben")

Getting a pre-allocated Array populated with typed data is the fastest way to query Datomic with Molecule. Looping the Array in a while loop with a mutable index pointer will also be the fastest way to traverse the data set.

The Array is only populated with n rows of type-casted tuples.

date: java.util.Date
n: Int Number of rows returned
conn: Implicit Conn value in scope
returns: Array[Tpl] where Tpl is a tuple of data matching molecule

Definition Classes: GetArray
See also: Manual on since

def getArraySince(date: Date)(implicit conn: Conn, ev: ClassTag[(A, B, C, D, E, F, G, H, I)]): Array[(A, B, C, D, E, F, G, H, I)]

Get Array of all rows as tuples matching molecule since date.

Get Array of all rows as tuples matching molecule since date.

Get data added/retracted since a human point in time (a java.util.Date).

// Transact 3 times (`inst` retrieves transaction time/Date from tx report)
val date1 = Person.name("Ann").save.inst
val date2 = Person.name("Ben").save.inst
val date3 = Person.name("Cay").save.inst

// Current values
Person.name.get === List("Ann", "Ben", "Cay")

// Ben and Cay added since date1
Person.name.getArraySince(date1) === Array("Ben", "Cay")

// Cay added since date2
Person.name.getArraySince(date2) === Array("Cay")

// Nothing added since date3
Person.name.getArraySince(date3) === Nil

Getting a pre-allocated Array populated with typed data is the fastest way to query Datomic with Molecule. Looping the Array in a while loop with a mutable index pointer will also be the fastest way to traverse the data set.

date: java.util.Date
conn: Implicit Conn value in scope
returns: Array[Tpl] where Tpl is a tuple of data matching molecule

Definition Classes: GetArray
See also: Manual on since

def getArraySince(tx: TxReport, n: Int)(implicit conn: Conn, ev: ClassTag[(A, B, C, D, E, F, G, H, I)]): Array[(A, B, C, D, E, F, G, H, I)]

Get Array of n rows as tuples matching molecule since tx.

Get Array of n rows as tuples matching molecule since tx.

Datomic's internal since can take a transaction entity id as argument to retrieve a database value since that transaction (excluding the transaction itself).

Instead of supplying the transaction entity id, in Molecule we supply a TxReport that contains the transaction entity id (which is used as argument to Datomic internally). This is more convenient when using Molecule since we get a TxReport from transaction operations like get, update, retract etc.

// Get tx reports for 3 transactions
val tx1 = Person.name("Ann").save
val tx2 = Person.name("Ben").save
val tx3 = Person.name("Cay").save

// Current values
Person.name.get === List("Ann", "Ben", "Cay")

// Ben and Cay added since tx1
Person.name.getArraySince(tx1) === Array("Ben", "Cay")

// Ben and Cay added since tx1 - only n (1) rows returned
Person.name.getArraySince(tx1, 1) === Array("Ben")

Getting a pre-allocated Array populated with typed data is the fastest way to query Datomic with Molecule. Looping the Array in a while loop with a mutable index pointer will also be the fastest way to traverse the data set.

The Array is only populated with n rows of type-casted tuples.

tx: TxReport
n: Int Number of rows returned
conn: Implicit Conn value in scope
returns: Array[Tpl] where Tpl is a tuple of data matching molecule

Definition Classes: GetArray
See also: Manual on since

def getArraySince(tx: TxReport)(implicit conn: Conn, ev: ClassTag[(A, B, C, D, E, F, G, H, I)]): Array[(A, B, C, D, E, F, G, H, I)]

Get Array of all rows as tuples matching molecule since tx.

Get Array of all rows as tuples matching molecule since tx.

Datomic's internal since can take a transaction entity id as argument to retrieve a database value since that transaction (excluding the transaction itself).

Instead of supplying the transaction entity id, in Molecule we supply a TxReport that contains the transaction entity id (which is used as argument to Datomic internally). This is more convenient when using Molecule since we get a TxReport from transaction operations like get, update, retract etc.

// Get tx reports for 3 transactions
val tx1 = Person.name("Ann").save
val tx2 = Person.name("Ben").save
val tx3 = Person.name("Cay").save

// Current values
Person.name.get === List("Ann", "Ben", "Cay")

// Ben and Cay added since tx1
Person.name.getArraySince(tx1) === Array("Ben", "Cay")

// Cay added since tx2
Person.name.getArraySince(tx2) === Array("Cay")

// Nothing added since tx3
Person.name.getArraySince(tx3) === Nil

Getting a pre-allocated Array populated with typed data is the fastest way to query Datomic with Molecule. Looping the Array in a while loop with a mutable index pointer will also be the fastest way to traverse the data set.

tx: TxReport
conn: Implicit Conn value in scope
returns: Array[Tpl] where Tpl is a tuple of data matching molecule

Definition Classes: GetArray
See also: Manual on since

def getArraySince(t: Long, n: Int)(implicit conn: Conn, ev: ClassTag[(A, B, C, D, E, F, G, H, I)]): Array[(A, B, C, D, E, F, G, H, I)]

Get Array of n rows as tuples matching molecule since transaction time t.

Get Array of n rows as tuples matching molecule since transaction time t.

Transaction time t is an auto-incremented transaction number assigned internally by Datomic.

t can for instance be retrieved by calling t on the tx report returned from transactional operations and then be used to get data since that point in time (excluding that transaction):

// 3 transaction times `t`
val t1 = Person.name("Ann").save.t
val t2 = Person.name("Ben").save.t
val t3 = Person.name("Cay").save.t

// Current values
Person.name.get === List("Ann", "Ben", "Cay")

// Ben and Cay added since transaction time t 1028
Person.name.getArraySince(t1) === Array("Ben", "Cay")

// Ben and Cay added since transaction time t 1028 - only n (1) rows returned
Person.name.getArraySince(t1, 1) === Array("Ben")

Getting a pre-allocated Array populated with typed data is the fastest way to query Datomic with Molecule. Looping the Array in a while loop with a mutable index pointer will also be the fastest way to traverse the data set.

The Array is only populated with n rows of type-casted tuples.

t: Transaction time t
n: Int Number of rows returned
conn: Implicit Conn value in scope
returns: Array[Tpl] where Tpl is a tuple of data matching molecule

Definition Classes: GetArray
See also: Manual on since

def getArraySince(t: Long)(implicit conn: Conn, ev: ClassTag[(A, B, C, D, E, F, G, H, I)]): Array[(A, B, C, D, E, F, G, H, I)]

Get Array of all rows as tuples matching molecule since transaction time t.

Get Array of all rows as tuples matching molecule since transaction time t.

Transaction time t is an auto-incremented transaction number assigned internally by Datomic.

t can for instance be retrieved by calling t on the tx report returned from transactional operations and then be used to get data since that point in time (excluding that transaction):

// 3 transaction times `t`
val t1 = Person.name("Ann").save.t
val t2 = Person.name("Ben").save.t
val t3 = Person.name("Cay").save.t

// Current values
Person.name.get === List("Ann", "Ben", "Cay")

// Ben and Cay added since transaction time t 1028
Person.name.getArraySince(t1) === Array("Ben", "Cay")

// Cay added since transaction time t 1030
Person.name.getArraySince(t2) === Array("Cay")

// Nothing added since transaction time t 1032
Person.name.getArraySince(t3) === Nil

Getting a pre-allocated Array populated with typed data is the fastest way to query Datomic with Molecule. Looping the Array in a while loop with a mutable index pointer will also be the fastest way to traverse the data set.

t: Transaction time t
conn: Implicit Conn value in scope
returns: Array[Tpl] where Tpl is a tuple of data matching molecule

Definition Classes: GetArray
See also: Manual on since

def getArrayWith(txData: List[_], n: Int)(implicit conn: Conn, ev: ClassTag[(A, B, C, D, E, F, G, H, I)]): Array[(A, B, C, D, E, F, G, H, I)]

Get Array of n rows as tuples matching molecule with applied raw transaction data.

Get Array of n rows as tuples matching molecule with applied raw transaction data.

Apply raw transaction data to in-memory "branch" of db without affecting db to see how it would then look:

// Live size of Person db
Person.name.get.size === 150

// Read some transaction data from file
val data_rdr2 = new FileReader("examples/resources/seattle/seattle-data1a.dtm")
val newDataTx = Util.readAll(data_rdr2).get(0).asInstanceOf[java.util.List[Object]]

// Imagine future db - 100 persons would be added, apparently
Person.name.getArrayWith(newDataTx).size === 250

// Imagine future db - Let's just take 10
Person.name.getArrayWith(newDataTx, 10).size === 10

Getting a pre-allocated Array populated with typed data is the fastest way to query Datomic with Molecule. Looping the Array in a while loop with a mutable index pointer will also be the fastest way to traverse the data set.

The Array is only populated with n rows of type-casted tuples.

txData: Raw transaction data as java.util.List[Object]
n: Int Number of rows returned
conn: Implicit Conn value in scope
returns: Array[Tpl] where Tpl is a tuple of data matching molecule

Definition Classes: GetArray
See also: Manual

def getArrayWith(txData: List[_])(implicit conn: Conn, ev: ClassTag[(A, B, C, D, E, F, G, H, I)]): Array[(A, B, C, D, E, F, G, H, I)]

Get Array of all rows as tuples matching molecule with applied raw transaction data.

Get Array of all rows as tuples matching molecule with applied raw transaction data.

Apply raw transaction data to in-memory "branch" of db without affecting db to see how it would then look:

// Live size of Person db
Person.name.get.size === 150

// Read some transaction data from file
val data_rdr2 = new FileReader("examples/resources/seattle/seattle-data1a.dtm")
val newDataTx = Util.readAll(data_rdr2).get(0).asInstanceOf[java.util.List[Object]]

// Imagine future db - 100 persons would be added, apparently
Person.name.getArrayWith(newDataTx).size === 250

Getting a pre-allocated Array populated with typed data is the fastest way to query Datomic with Molecule. Looping the Array in a while loop with a mutable index pointer will also be the fastest way to traverse the data set.

txData: Raw transaction data as java.util.List[Object]
conn: Implicit Conn value in scope
returns: Array[Tpl] where Tpl is a tuple of data matching molecule

Definition Classes: GetArray
See also: Manual

def getArrayWith(n: Int, txMolecules: Seq[Seq[Statement]]*)(implicit conn: Conn, ev: ClassTag[(A, B, C, D, E, F, G, H, I)]): Array[(A, B, C, D, E, F, G, H, I)]

Get Array of n rows as tuples matching molecule with applied molecule transaction data.

Get Array of n rows as tuples matching molecule with applied molecule transaction data.

Apply one or more molecule transactions to in-memory "branch" of db without affecting db to see how it would then look:

// Current state
val List(ben, liz) = Person.name.likes.insert(
  ("Ben", "pasta"),
  ("Liz", "pizza")
).eids

// Test multiple transactions
Person.name.likes.getArrayWith(
  Person(ben).likes("sushi").getUpdateTx,
  Person(liz).likes("cake").getUpdateTx
) === Array(
  ("Ben", "sushi")
  ("Liz", "cake")
)

// Same as above, but only n (1) rows returned:
Person.name.likes.getArrayWith(
  1
  Person(ben).likes("sushi").getUpdateTx,
  Person(liz).likes("cake").getUpdateTx
) === Array(
  ("Ben", "sushi")
)

Getting a pre-allocated Array populated with typed data is the fastest way to query Datomic with Molecule. Looping the Array in a while loop with a mutable index pointer will also be the fastest way to traverse the data set.

The Array is only populated with n rows of type-casted tuples.

n: Int Number of rows returned
txMolecules: Transaction statements from applied Molecules with test data
conn: Implicit Conn value in scope
returns: Array[Tpl] where Tpl is a tuple of data matching molecule

Definition Classes: GetArray
Note: Note how the n parameter has to come before the txMolecules vararg.
See also: Manual

def getArrayWith(txMolecules: Seq[Seq[Statement]]*)(implicit conn: Conn, ev: ClassTag[(A, B, C, D, E, F, G, H, I)]): Array[(A, B, C, D, E, F, G, H, I)]

Get Array of all rows as tuples matching molecule with applied molecule transaction data.

Get Array of all rows as tuples matching molecule with applied molecule transaction data.

Apply one or more molecule transactions to in-memory "branch" of db without affecting db to see how it would then look:

// Current state
val ben = Person.name("Ben").likes("pasta").save.eid

// Base data
Person.name.likes.getArrayWith(
  // apply imaginary transaction data
  Person(ben).likes("sushi").getUpdateTx
) === Array(
  // Effect: Ben would like sushi if tx was applied
  ("Ben", "sushi")
)

// Current state is still the same
Person.name.likes.get === Array(
  ("Ben", "pasta")
)

Multiple transactions can be applied to test more complex what-if scenarios!

Getting a pre-allocated Array populated with typed data is the fastest way to query Datomic with Molecule. Looping the Array in a while loop with a mutable index pointer will also be the fastest way to traverse the data set.

txMolecules: Transaction statements from applied Molecules with test data
conn: Implicit Conn value in scope
returns: Array[Tpl] where Tpl is a tuple of data matching molecule

Definition Classes: GetArray
See also: Manual

def getAsOf(date: Date, n: Int)(implicit conn: Conn, ev: ClassTag[(A, B, C, D, E, F, G, H, I)]): List[(A, B, C, D, E, F, G, H, I)]

Get List of n rows as tuples matching molecule as of date.

Get List of n rows as tuples matching molecule as of date.

Get data at a human point in time (a java.util.Date).

val beforeInsert = new java.util.Date

// Insert
val tx1 = Person.name.age insert List(
  ("Ben", 42),
  ("Liz", 37)
)
val List(ben, liz) = tx1.eids
val afterInsert = new java.util.Date

// Update
val tx2 = Person(ben).age(43).update
val afterUpdate = new java.util.Date

// Get List of all rows as of afterUpdate
Person.name.age.getAsOf(afterUpdate) === List(
  ("Ben", 43),
  ("Liz", 37)
)

// Get List of n rows as of afterUpdate
Person.name.age.getAsOf(afterUpdate, 1) === List(
  ("Ben", 43)
)

date: java.util.Date
n: Int Number of rows returned
conn: Implicit Conn value in scope
returns: List[Tpl] where Tpl is a tuple of data matching molecule

Definition Classes: GetList
See also: Manual on getAsOf

def getAsOf(date: Date)(implicit conn: Conn, ev: ClassTag[(A, B, C, D, E, F, G, H, I)]): List[(A, B, C, D, E, F, G, H, I)]

Get List of all rows as tuples matching molecule as of date.

Get List of all rows as tuples matching molecule as of date.

Get data at a human point in time (a java.util.Date).

val beforeInsert = new java.util.Date

// Insert
val tx1 = Person.name.age insert List(
  ("Ben", 42),
  ("Liz", 37),
)
val List(ben, liz) = tx1.eids
val afterInsert = new java.util.Date

// Update
val tx2 = Person(ben).age(43).update
val afterUpdate = new java.util.Date

// Retract
val tx3 = ben.retract
val afterRetract = new java.util.Date

// No data yet before insert
Person.name.age.getAsOf(beforeInsert) === Nil

// Get List of all rows as of afterInsert
Person.name.age.getAsOf(afterInsert) === List(
  ("Ben", 42),
  ("Liz", 37)´
)

// Get List of all rows as of afterUpdate
Person.name.age.getAsOf(afterUpdate) === List(
  ("Ben", 43), // Ben now 43
  ("Liz", 37)
)

// Get List of all rows as of afterRetract
Person.name.age.getAsOf(afterRetract) === List(
  ("Liz", 37) // Ben gone
)

date: java.util.Date
conn: Implicit Conn value in scope
returns: List[Tpl] where Tpl is a tuple of data matching molecule

Definition Classes: GetList
See also: Manual on getAsOf

def getAsOf(tx: TxReport, n: Int)(implicit conn: Conn, ev: ClassTag[(A, B, C, D, E, F, G, H, I)]): List[(A, B, C, D, E, F, G, H, I)]

Get List of n rows as tuples matching molecule as of tx.

Get List of n rows as tuples matching molecule as of tx.

Datomic's internal asOf method can take a transaction entity id as argument to retrieve a database value as of that transaction (including).

Instead of supplying the transaction entity id, in Molecule we supply a TxReport that contains the transaction entity id (which is used as argument to Datomic internally). This is more convenient when using Molecule since we get a TxReport from transaction operations like get, update, retract etc.

// Insert (tx report 1)
val tx1 = Person.name.age insert List(
  ("Ben", 42),
  ("Liz", 37)
)
val List(ben, liz) = tx1.eids

// Update (tx report 2)
val tx2 = Person(ben).age(43).update

// Current data
Person.name.age.get === List(
  ("Ben", 43),
  ("Liz", 37)
)

// Get List of all rows as of tx2 (after update)
Person.name.age.getAsOf(tx2) === List(
  ("Ben", 43),
  ("Liz", 37)
)

// Get List of n rows as of tx2 (after update)
Person.name.age.getAsOf(tx2, 1) === List(
  ("Ben", 43)
)

tx: TxReport (returned from all molecule transaction operations)
n: Int Number of rows returned
conn: Implicit Conn value in scope
returns: List[Tpl] where Tpl is a tuple of data matching molecule

Definition Classes: GetList
See also: Manual on getAsOf

def getAsOf(tx: TxReport)(implicit conn: Conn, ev: ClassTag[(A, B, C, D, E, F, G, H, I)]): List[(A, B, C, D, E, F, G, H, I)]

Get List of all rows as tuples matching molecule as of tx.

Get List of all rows as tuples matching molecule as of tx.

Datomic's internal asOf method can take a transaction entity id as argument to retrieve a database value as of that transaction (including).

Instead of supplying the transaction entity id, in Molecule we supply a TxReport that contains the transaction entity id (which is used as argument to Datomic internally). This is more convenient when using Molecule since we get a TxReport from transaction operations like get, update, retract etc.

// Insert (tx report 1)
val tx1 = Person.name.age insert List(
  ("Ben", 42),
  ("Liz", 37),
)
val List(ben, liz) = tx1.eids

// Update (tx report 2)
val tx2 = Person(ben).age(43).update

// Retract (tx report 3)
val tx3 = ben.retract

// Get List of all rows as of tx1 (after insert)
Person.name.age.getAsOf(tx1) === List(
  ("Ben", 42),
  ("Liz", 37)
)

// Get List of all rows as of tx2 (after update)
Person.name.age.getAsOf(tx2) === List(
  ("Ben", 43), // Ben now 43
  ("Liz", 37)
)

// Get List of all rows as of tx3 (after retract)
Person.name.age.getAsOf(tx3) === List(
  ("Liz", 37) // Ben gone
)

tx: TxReport (returned from all molecule transaction operations)
conn: Implicit Conn value in scope
returns: List[Tpl] where Tpl is a tuple of data matching molecule

Definition Classes: GetList
See also: Manual on getAsOf

def getAsOf(t: Long, n: Int)(implicit conn: Conn, ev: ClassTag[(A, B, C, D, E, F, G, H, I)]): List[(A, B, C, D, E, F, G, H, I)]

Get List of n rows as tuples matching molecule as of transaction time t.

Get List of n rows as tuples matching molecule as of transaction time t.

Transaction time t is an auto-incremented transaction number assigned internally by Datomic.

t can for instance be retrieved in a getHistory call for an attribute and then be used to get data as of that point in time (including that transaction):

// Insert (t 1028)
val List(ben, liz) = Person.name.age insert List(
  ("Ben", 42),
  ("Liz", 37),
) eids

// Update (t 1031)
Person(ben).age(43).update

// History of Ben
Person(ben).age.t.op.getHistory.sortBy(r => (r._2, r._3)) === List(
  (42, 1028, true),  // Insert:  42 asserted
  (42, 1031, false), // Update:  42 retracted
  (43, 1031, true),  //          43 asserted
)

// Get List of all all rows as of transaction t 1031 (after update)
Person.name.age.getAsOf(1031) === List(
  ("Ben", 43),
  ("Liz", 37)
)

// Get List of n rows as of transaction t 1031 (after update)
Person.name.age.getAsOf(1031, 1) === List(
  ("Ben", 43)
)

t: Long Transaction time t
n: Int Number of rows returned
conn: Implicit Conn value in scope
returns: List[Tpl] where Tpl is a tuple of data matching molecule

Definition Classes: GetList
See also: Manual on getAsOf

def getAsOf(t: Long)(implicit conn: Conn, ev: ClassTag[(A, B, C, D, E, F, G, H, I)]): List[(A, B, C, D, E, F, G, H, I)]

Get List of all rows as tuples matching molecule as of transaction time t.

Get List of all rows as tuples matching molecule as of transaction time t.

Transaction time t is an auto-incremented transaction number assigned internally by Datomic.

t can for instance be retrieved in a getHistory call for an attribute and then be used to get data as of that point in time (including that transaction):

// Insert (t 1028)
val List(ben, liz) = Person.name.age insert List(
  ("Ben", 42),
  ("Liz", 37),
) eids

// Update (t 1031)
Person(ben).age(43).update

// Retract (t 1032)
ben.retract

// History of Ben
Person(ben).age.t.op.getHistory.sortBy(r => (r._2, r._3)) === List(
  (42, 1028, true),  // Insert:  42 asserted
  (42, 1031, false), // Update:  42 retracted
  (43, 1031, true),  //          43 asserted
  (43, 1032, false)  // Retract: 43 retracted
)

// Get List of all rows as of transaction t 1028 (after insert)
Person.name.age.getAsOf(1028) === List(
  ("Liz", 37),
  ("Ben", 42)
)

// Get List of all rows as of transaction t 1031 (after update)
Person.name.age.getAsOf(1031) === List(
  ("Liz", 37),
  ("Ben", 43)
)

// Get List of all rows as of transaction t 1032 (after retract)
Person.name.age.getAsOf(1032) === List(
  ("Liz", 37)
)

t: Transaction time t
conn: Implicit Conn value in scope
returns: List[Tpl] where Tpl is a tuple of data matching molecule

Definition Classes: GetList
See also: Manual on getAsOf

final def getClass(): Class[_]

Definition Classes: AnyRef → Any
Annotations: @native()

def getHistory(implicit conn: Conn, ev: ClassTag[(A, B, C, D, E, F, G, H, I)]): List[(A, B, C, D, E, F, G, H, I)]

Get history of operations as List on an attribute in the db.

Get history of operations as List on an attribute in the db.

Generic datom attributes that can be called when getHistory is called:

e - Entity id
a - Attribute name
v - Attribute value
ns - Namespace name
tx - TxReport
t - Transaction time t
txInstant - Transaction time as java.util.Date
op - Operation: true (add) or false (retract)

Example:

// Insert (t 1028)
val List(ben, liz) = Person.name.age insert List(
  ("Ben", 42),
  ("Liz", 37),
) eids

// Update (t 1031)
Person(ben).age(43).update

// Retract (t 1032)
ben.retract

// History of Ben
Person(ben).age.t.op.getHistory.sortBy(r => (r._2, r._3)) === List(
  (42, 1028, true),  // Insert:  42 asserted
  (42, 1031, false), // Update:  42 retracted
  (43, 1031, true),  //          43 asserted
  (43, 1032, false)  // Retract: 43 retracted
)

conn: Implicit Conn value in scope
returns: List[Tpl] where Tpl is a tuple of data matching molecule

Definition Classes: GetList
See also: manual for more info on generic attributes.

def getIterable(implicit conn: Conn, ev: ClassTag[(A, B, C, D, E, F, G, H, I)]): Iterable[(A, B, C, D, E, F, G, H, I)]

Get Iterable of all rows as tuples matching the molecule.

Get Iterable of all rows as tuples matching the molecule.

Rows are lazily type-casted on each call to iterator.next().

Person.name.age.getIterable.toList === List(
  ("Ben", 42),
  ("Liz", 37),
)

conn: Implicit Conn value in scope
returns: Iterable[Tpl] where Tpl is a tuple of types matching the attributes of the molecule

Definition Classes: GetIterable

def getIterableAsOf(date: Date)(implicit conn: Conn, ev: ClassTag[(A, B, C, D, E, F, G, H, I)]): Iterable[(A, B, C, D, E, F, G, H, I)]

Get Iterable of all rows as tuples matching molecule as of date.

Get Iterable of all rows as tuples matching molecule as of date.

Get data at a human point in time (a java.util.Date).

val beforeInsert = new java.util.Date

// Insert
val tx1 = Person.name.age insert List(
  ("Ben", 42),
  ("Liz", 37)
)
val List(ben, liz) = tx1.eids
val afterInsert = new java.util.Date

// Update
val tx2 = Person(ben).age(43).update
val afterUpdate = new java.util.Date

// Retract
val tx3 = ben.retract
val afterRetract = new java.util.Date

// Get Iterable of all rows as of beforeInsert
val iterable0: Iterable[(String, Int)] = Person.name.age.getIterableAsOf(beforeInsert)
val iterator0: Iterator[(String, Int)] = iterable0.iterator
iterator0.hasNext === false // Nothing yet

// Get Iterable of all rows as of afterInsert
val iterable1: Iterable[(String, Int)] = Person.name.age.getIterableAsOf(afterInsert)
val iterator1: Iterator[(String, Int)] = iterable1.iterator

// Type casting lazily performed with each call to `next`
iterator1.next === ("Ben", 42)
iterator1.next === ("Liz", 37)

// Get Iterable of all rows as of afterUpdate
val iterable2: Iterable[(String, Int)] = Person.name.age.getIterableAsOf(afterUpdate)
val iterator2: Iterator[(String, Int)] = iterable2.iterator

// Type casting lazily performed with each call to `next`
iterator2.next === ("Ben", 43) // Ben now 43
iterator2.next === ("Liz", 37)

// Get Iterable of all rows as of afterRetract
val iterable3: Iterable[(String, Int)] = Person.name.age.getIterableAsOf(afterRetract)
val iterator3: Iterator[(String, Int)] = iterable3.iterator

// Type casting lazily performed with each call to `next`
iterator3.next === ("Liz", 37)
iterator3.hasNext === false // Ben gone

date: java.util.Date
conn: Implicit Conn value in scope
returns: Iterable[Tpl] where Tpl is tuple of data matching molecule

Definition Classes: GetIterable
See also: Manual on getAsOf

def getIterableAsOf(tx: TxReport)(implicit conn: Conn, ev: ClassTag[(A, B, C, D, E, F, G, H, I)]): Iterable[(A, B, C, D, E, F, G, H, I)]

Get Iterable of all rows as tuples matching molecule as of tx.

Get Iterable of all rows as tuples matching molecule as of tx.

Datomic's internal asOf method can take a transaction entity id as argument to retrieve a database value as of that transaction (including).

Instead of supplying the transaction entity id, in Molecule we supply a TxReport that contains the transaction entity id (which is used as argument to Datomic internally). This is more convenient when using Molecule since we get a TxReport from transaction operations like get, update, retract etc.

// Insert (tx report 1)
val tx1 = Person.name.age insert List(
  ("Ben", 42),
  ("Liz", 37)
)
val List(ben, liz) = tx1.eids

// Update (tx report 2)
val tx2 = Person(ben).age(43).update

// Retract (tx report 3)
val tx3 = ben.retract

// Get Iterable of all rows as of tx1 (after insert)
val iterable1: Iterable[(String, Int)] = Person.name.age.getIterableAsOf(tx1)
val iterator1: Iterator[(String, Int)] = iterable1.iterator

// Type casting lazily performed with each call to `next`
iterator1.next === ("Ben", 42)
iterator1.next === ("Liz", 37)

// Get Iterable of all rows as of tx2 (after update)
val iterable2: Iterable[(String, Int)] = Person.name.age.getIterableAsOf(tx2)
val iterator2: Iterator[(String, Int)] = iterable2.iterator

// Type casting lazily performed with each call to `next`
iterator2.next === ("Ben", 43) // Ben now 43
iterator2.next === ("Liz", 37)

// Get Iterable of all rows as of tx3 (after retract)
val iterable3: Iterable[(String, Int)] = Person.name.age.getIterableAsOf(tx3)
val iterator3: Iterator[(String, Int)] = iterable3.iterator

// Type casting lazily performed with each call to `next`
iterator3.next === ("Liz", 37)
iterator3.hasNext === false // Ben gone

tx: TxReport (returned from all molecule transaction operations)
conn: Implicit Conn value in scope
returns: Iterable[Tpl] where Tpl is tuple of data matching molecule

Definition Classes: GetIterable
See also: Manual on getAsOf

def getIterableAsOf(t: Long)(implicit conn: Conn, ev: ClassTag[(A, B, C, D, E, F, G, H, I)]): Iterable[(A, B, C, D, E, F, G, H, I)]

Get Iterable of all rows as tuples matching molecule as of transaction time t.

Get Iterable of all rows as tuples matching molecule as of transaction time t.

Transaction time t is an auto-incremented transaction number assigned internally by Datomic.

Call getIterableAsOf for large result sets to maximize runtime performance. Data is lazily type-casted on each call to next on the iterator.

t can for instance be retrieved in a getHistory call for an attribute and then be used to get data as of that point in time (including that transaction):

// Insert (t 1028)
val List(ben, liz) = Person.name.age insert List(
  ("Ben", 42),
  ("Liz", 37)
) eids

// Update (t 1031)
Person(ben).age(43).update

// Retract (t 1032)
ben.retract

// History of Ben
Person(ben).age.t.op.getHistory.sortBy(r => (r._2, r._3)) === List(
  (42, 1028, true),  // Insert:  42 asserted
  (42, 1031, false), // Update:  42 retracted
  (43, 1031, true),  //          43 asserted
  (43, 1032, false)  // Retract: 43 retracted
)

// Get Iterable of all rows as of transaction t 1028 (after insert)
val iterable1: Iterable[(String, Int)] = Person.name.age.getIterableAsOf(1028)
val iterator1: Iterator[(String, Int)] = iterable1.iterator

// Type casting lazily performed with each call to `next`
iterator1.next === ("Liz", 37)
iterator1.next === ("Ben", 42)

// Get Iterable of all rows as of transaction t 1031 (after update)
val iterable2: Iterable[(String, Int)] = Person.name.age.getIterableAsOf(1031)
val iterator2: Iterator[(String, Int)] = iterable2.iterator

// Type casting lazily performed with each call to `next`
iterator2.next === ("Liz", 37)
iterator2.next === ("Ben", 43) // Ben now 43

// Get Iterable of all rows as of transaction t 1032 (after retract)
val iterable3: Iterable[(String, Int)] = Person.name.age.getIterableAsOf(1032)
val iterator3: Iterator[(String, Int)] = iterable3.iterator

// Type casting lazily performed with each call to `next`
iterator3.next === ("Liz", 37)
iterator3.hasNext === false // Ben gone

t: Transaction time t
conn: Implicit Conn value in scope
returns: Iterable[Tpl] where Tpl is tuple of data matching molecule

Definition Classes: GetIterable
See also: Manual on getAsOf

def getIterableSince(date: Date)(implicit conn: Conn, ev: ClassTag[(A, B, C, D, E, F, G, H, I)]): Iterable[(A, B, C, D, E, F, G, H, I)]

Get Iterable of all rows as tuples matching molecule since date.

Get Iterable of all rows as tuples matching molecule since date.

Get data added/retracted since a human point in time (a java.util.Date).

// Transact 3 times (`inst` retrieves transaction time from tx report)
val date1 = Person.name("Ann").save.inst
val date2 = Person.name("Ben").save.inst
val date3 = Person.name("Cay").save.inst

// Current values
Person.name.getIterable.iterator.toList === List("Ann", "Ben", "Cay")

// Ben and Cay added since date1
Person.name.getIterableSince(date1).iterator.toList === List("Ben", "Cay")

// Cay added since date2
Person.name.getIterableSince(date2).iterator.toList === List("Cay")

// Nothing added since date3
Person.name.getIterableSince(date3).iterator.toList === Nil

date: java.util.Date
conn: Implicit Conn value in scope
returns: Iterable[Tpl] where Tpl is tuple of data matching molecule

Definition Classes: GetIterable
See also: Manual on since

def getIterableSince(tx: TxReport)(implicit conn: Conn, ev: ClassTag[(A, B, C, D, E, F, G, H, I)]): Iterable[(A, B, C, D, E, F, G, H, I)]

Get Iterable of all rows as tuples matching molecule since tx.

Get Iterable of all rows as tuples matching molecule since tx.

Datomic's internal since method can take a transaction entity id as argument to retrieve a database value since that transaction (excluding the transaction itself).

Instead of supplying the transaction entity id, in Molecule we supply a TxReport that contains the transaction entity id (which is used as argument to Datomic internally). This is more convenient when using Molecule since we get a TxReport from transaction operations like get, update, retract etc.

// Get tx reports for 3 transactions
val tx1 = Person.name("Ann").save
val tx2 = Person.name("Ben").save
val tx3 = Person.name("Cay").save

// Current values
Person.name.getIterable.iterator.toList === List("Ann", "Ben", "Cay")

// Ben and Cay added since tx1
Person.name.getIterableSince(tx1).iterator.toList === List("Ben", "Cay")

// Cay added since tx2
Person.name.getIterableSince(tx2).iterator.toList === List("Cay")

// Nothing added since tx3
Person.name.getIterableSince(tx3).iterator.toList === Nil

tx: TxReport
conn: Implicit Conn value in scope
returns: Iterable[Tpl] where Tpl is tuple of data matching molecule

Definition Classes: GetIterable
See also: Manual on since

def getIterableSince(t: Long)(implicit conn: Conn, ev: ClassTag[(A, B, C, D, E, F, G, H, I)]): Iterable[(A, B, C, D, E, F, G, H, I)]

Get Iterable of all rows as tuples matching molecule since transaction time t.

Get Iterable of all rows as tuples matching molecule since transaction time t.

Transaction time t is an auto-incremented transaction number assigned internally by Datomic.

Call getIterableSince for large result sets to maximize runtime performance. Data is lazily type-casted on each call to next on the iterator.

t can for instance be retrieved calling t on the tx report returned from transactional operations and then be used to get data since that point in time (excluding that transaction):

// 3 transaction times `t`
val t1 = Person.name("Ann").save.t
val t2 = Person.name("Ben").save.t
val t3 = Person.name("Cay").save.t

// Current values as Iterable
Person.name.getIterable.iterator.toList === List("Ann", "Ben", "Cay")

// Ben and Cay added since transaction time t1
Person.name.getIterableSince(t1).iterator.toList === List("Ben", "Cay")

// Cay added since transaction time t2
Person.name.getIterableSince(t2).iterator.toList === List("Cay")

// Nothing added since transaction time t3
Person.name.getIterableSince(t3).iterator.toList === Nil

t: Transaction time t
conn: Implicit Conn value in scope
returns: Iterable[Tpl] where Tpl is tuple of data matching molecule

Definition Classes: GetIterable
See also: Manual on since

def getIterableWith(txData: List[_])(implicit conn: Conn, ev: ClassTag[(A, B, C, D, E, F, G, H, I)]): Iterable[(A, B, C, D, E, F, G, H, I)]

Get Iterable of all rows as tuples matching molecule with applied raw transaction data.

Get Iterable of all rows as tuples matching molecule with applied raw transaction data.

Apply raw transaction data to in-memory "branch" of db without affecting db to see how it would then look:

// Live size of Person db
Person.name.get.size === 150

// Read some transaction data from file
val data_rdr2 = new FileReader("examples/resources/seattle/seattle-data1a.dtm")
val newDataTx = Util.readAll(data_rdr2).get(0).asInstanceOf[java.util.List[Object]]

// Imagine future db - 100 persons would be added, apparently
Person.name.getIterableWith(newDataTx).size === 250

txData: Raw transaction data as java.util.List[Object]
conn: Implicit Conn value in scope
returns: Iterable of molecule data

Definition Classes: GetIterable
See also: Manual

def getIterableWith(txMolecules: Seq[Seq[Statement]]*)(implicit conn: Conn, ev: ClassTag[(A, B, C, D, E, F, G, H, I)]): Iterable[(A, B, C, D, E, F, G, H, I)]

Get Iterable of all rows as tuples matching molecule with applied molecule transaction data.

Get Iterable of all rows as tuples matching molecule with applied molecule transaction data.

Apply one or more molecule transactions to in-memory "branch" of db without affecting db to see how it would then look:

// Current state
val ben = Person.name("Ben").likes("pasta").save.eid

// Base data
Person.name.likes.getIterableWith(
  // apply imaginary transaction data
  Person(ben).likes("sushi").getUpdateTx
).iterator.toList === List(
  // Effect: Ben would like sushi if tx was applied
  ("Ben", "sushi")
)

// Current state is still the same
Person.name.likes.get === List(
  ("Ben", "pasta")
)

Multiple transactions can be applied to test more complex what-if scenarios!

txMolecules: Transaction statements from applied Molecules with test data
conn: Implicit Conn value in scope
returns: Iterable of molecule data

Definition Classes: GetIterable
See also: Manual

def getJson(n: Int)(implicit conn: Conn): String

Get json data for n rows matching molecule

Person.name.age.getJson(1) ===
  """[
    |{"person.name": "Ben", "person.age": 42}
    |]""".stripMargin

Namespace.Attribute is used as json fields. Values are quoted when necessary. Nested data becomes json objects etc.

n: Number of rows returned
conn: Implicit Conn value in scope
returns: String of json

Definition Classes: GetJson
See also: Manual on getJson

def getJson(implicit conn: Conn): String

Get json data for all rows matching molecule.

Person.name.age.getJson ===
  """[
    |{"person.name": "Ben", "person.age": 42},
    |{"person.name": "Liz", "person.age": 37}
    |]""".stripMargin

Namespace.Attribute is used as json fields. Values are quoted when necessary. Nested data becomes json objects etc.

conn: Implicit Conn value in scope
returns: String of json

Definition Classes: GetJson
See also: Manual on getJson

def getJsonAsOf(date: Date, n: Int)(implicit conn: Conn): String

Get json data for n rows matching molecule as of tx.

Get json data for n rows matching molecule as of tx.

Get data at a human point in time (a java.util.Date).

val beforeInsert = new java.util.Date

// Insert
val tx1 = Person.name.age insert List(
  ("Ben", 42),
  ("Liz", 37)
)
val List(ben, liz) = tx1.eids
val afterInsert = new java.util.Date

// Update
val tx2 = Person(ben).age(43).update
val afterUpdate = new java.util.Date

// Get List of all rows as of afterUpdate
Person.name.age.getJsonAsOf(afterUpdate) ===
  """[
    |{"person.name": "Ben", "person.age": 43},
    |{"person.name": "Liz", "person.age": 37}
    |]""".stripMargin

// Get List of n rows as of afterUpdate
Person.name.age.getJsonAsOf(afterUpdate, 1) ===
  """[
    |{"person.name": "Ben", "person.age": 43}
    |]""".stripMargin

date: java.util.Date
n: Int Number of rows returned
conn: Implicit Conn value in scope
returns: String of json

Definition Classes: GetJson
See also: Manual on getAsOf

def getJsonAsOf(date: Date)(implicit conn: Conn): String

Get json data for all rows matching molecule as of date.

Get json data for all rows matching molecule as of date.

Get data at a human point in time (a java.util.Date).

val beforeInsert = new java.util.Date

// Insert
val tx1 = Person.name.age insert List(
  ("Ben", 42),
  ("Liz", 37),
)
val List(ben, liz) = tx1.eids
val afterInsert = new java.util.Date

// Update
val tx2 = Person(ben).age(43).update
val afterUpdate = new java.util.Date

// Retract
val tx3 = ben.retract
val afterRetract = new java.util.Date

// No data yet before insert
Person.name.age.getJsonAsOf(beforeInsert) === ""

// Get List of all rows as of afterInsert
Person.name.age.getJsonAsOf(afterInsert) ===
  """[
    |{"person.name": "Ben", "person.age": 42},
    |{"person.name": "Liz", "person.age": 37}
    |]""".stripMargin

// Get List of all rows as of afterUpdate
Person.name.age.getJsonAsOf(afterUpdate) ===
  """[
    |{"person.name": "Ben", "person.age": 43},
    |{"person.name": "Liz", "person.age": 37}
    |]""".stripMargin

// Get List of all rows as of afterRetract
Person.name.age.getJsonAsOf(afterRetract) ===
  """[
    |{"person.name": "Liz", "person.age": 37}
    |]""".stripMargin

date: java.util.Date
conn: Implicit Conn value in scope
returns: String of json

Definition Classes: GetJson
See also: Manual on getAsOf

def getJsonAsOf(tx: TxReport, n: Int)(implicit conn: Conn): String

Get json data for n rows matching molecule as of tx.

Get json data for n rows matching molecule as of tx.

Datomic's internal asOf method can take a transaction entity id as argument to retrieve a database value as of that transaction (including).

Instead of supplying the transaction entity id, in Molecule we supply a TxReport that contains the transaction entity id (which is used as argument to Datomic internally). This is more convenient when using Molecule since we get a TxReport from transaction operations like get, update, retract etc.

// Insert (tx report 1)
val tx1 = Person.name.age insert List(
  ("Ben", 42),
  ("Liz", 37)
)
val List(ben, liz) = tx1.eids

// Update (tx report 2)
val tx2 = Person(ben).age(43).update

// Get json for all rows as of transaction tx2 (after update) - Ben now 43
Person.name.age.getJsonAsOf(tx2) ===
  """[
    |{"person.name": "Ben", "person.age": 43},
    |{"person.name": "Liz", "person.age": 37}
    |]""".stripMargin

// Get json for n rows as of transaction tx2 (after update) - Ben now 43
Person.name.age.getJsonAsOf(tx2, 1) ===
  """[
    |{"person.name": "Ben", "person.age": 43}
    |]""".stripMargin

tx: TxReport (returned from all molecule transaction operations)
n: Int Number of rows returned
conn: Implicit Conn value in scope
returns: String of json

Definition Classes: GetJson
See also: Manual on getAsOf

def getJsonAsOf(tx: TxReport)(implicit conn: Conn): String

Get json data for all rows matching molecule as of tx.

Get json data for all rows matching molecule as of tx.

Datomic's internal asOf method can take a transaction entity id as argument to retrieve a database value as of that transaction (including).

Instead of supplying the transaction entity id, in Molecule we supply a TxReport that contains the transaction entity id (which is used as argument to Datomic internally). This is more convenient when using Molecule since we get a TxReport from transaction operations like get, update, retract etc.

// Insert (tx report 1)
val tx1 = Person.name.age insert List(
  ("Ben", 42),
  ("Liz", 37)
)
val List(ben, liz) = tx1.eids

// Update (tx report 2)
val tx2 = Person(ben).age(43).update

// Retract (tx report 3)
val tx3 = ben.retract

// Get json for all rows as of transaction tx1 (after insert)
Person.name.age.getJsonAsOf(tx1) ===
  """[
    |{"person.name": "Ben", "person.age": 42},
    |{"person.name": "Liz", "person.age": 37}
    |]""".stripMargin

// Get json for all rows as of transaction tx2 (after update) - Ben now 43
Person.name.age.getJsonAsOf(tx2) ===
  """[
    |{"person.name": "Ben", "person.age": 43},
    |{"person.name": "Liz", "person.age": 37}
    |]""".stripMargin

// Get json for all rows as of transaction tx3 (after retract) - Ben gone
Person.name.age.getJsonAsOf(tx3) ===
  """[
    |{"person.name": "Liz", "person.age": 37}
    |]""".stripMargin

tx: TxReport (returned from all molecule transaction operations)
conn: Implicit Conn value in scope
returns: String of json

Definition Classes: GetJson
See also: Manual on getAsOf

def getJsonAsOf(t: Long, n: Int)(implicit conn: Conn): String

Get json data for n rows matching molecule as of transaction time t.

Get json data for n rows matching molecule as of transaction time t.

Transaction time t is an auto-incremented transaction number assigned internally by Datomic.

t can for instance be retrieved in a getHistory call for an attribute and then be used to get data as of that point in time (including that transaction):

// Insert (t 1028)
val List(ben, liz) = Person.name.age insert List(
  ("Ben", 42),
  ("Liz", 37)
) eids

// Update (t 1031)
Person(ben).age(43).update

// History of Ben
Person(ben).age.t.op.getHistory.sortBy(r => (r._2, r._3)) === List(
  (42, 1028, true),  // Insert:  42 asserted
  (42, 1031, false), // Update:  42 retracted
  (43, 1031, true),  //          43 asserted
)

// Get json for all rows as of transaction t 1031 (after update)
Person.name.age.getJsonAsOf(1031) ===
  """[
    |{"person.name": "Ben", "person.age": 43},
    |{"person.name": "Liz", "person.age": 37}
    |]""".stripMargin

// Get json for n (1) rows as of transaction t 1031 (after update)
Person.name.age.getJsonAsOf(1031, 1) ===
  """[
    |{"person.name": "Ben", "person.age": 43}
    |]""".stripMargin

t: Transaction time t
n: Int Number of rows returned
conn: Implicit Conn value in scope
returns: String of json

Definition Classes: GetJson
See also: Manual on getAsOf

def getJsonAsOf(t: Long)(implicit conn: Conn): String

Get json data for all rows matching molecule as of transaction time t.

Get json data for all rows matching molecule as of transaction time t.

Transaction time t is an auto-incremented transaction number assigned internally by Datomic.

t can for instance be retrieved in a getHistory call for an attribute and then be used to get data as of that point in time (including that transaction):

// Insert (t 1028)
val List(ben, liz) = Person.name.age insert List(
  ("Ben", 42),
  ("Liz", 37)
) eids

// Update (t 1031)
Person(ben).age(43).update

// Retract (t 1032)
ben.retract

// History of Ben
Person(ben).age.t.op.getHistory.sortBy(r => (r._2, r._3)) === List(
  (42, 1028, true),  // Insert:  42 asserted
  (42, 1031, false), // Update:  42 retracted
  (43, 1031, true),  //          43 asserted
  (43, 1032, false)  // Retract: 43 retracted
)

// Get json for all rows as of transaction t 1028 (after insert)
Person.name.age.getJsonAsOf(1028) ===
  """[
    |{"person.name": "Ben", "person.age": 42},
    |{"person.name": "Liz", "person.age": 37}
    |]""".stripMargin

// Get json for all rows as of transaction t 1031 (after update) - Ben now 43
Person.name.age.getJsonAsOf(1031) ===
  """[
    |{"person.name": "Ben", "person.age": 43},
    |{"person.name": "Liz", "person.age": 37}
    |]""".stripMargin

// Get json for all rows as of transaction t 1032 (after retract) - Ben gone
Person.name.age.getJsonAsOf(1032) ===
  """[
    |{"person.name": "Liz", "person.age": 37}
    |]""".stripMargin

t: Transaction time t
conn: Implicit Conn value in scope
returns: String of json

Definition Classes: GetJson
See also: Manual on getAsOf

def getJsonComposite(conn: Conn, n: Int): String

Attributes: protected
Definition Classes: GetJson

def getJsonFlat(conn: Conn, n: Int): String

Attributes: protected
Definition Classes: GetJson

def getJsonSince(date: Date, n: Int)(implicit conn: Conn): String

Get json data for n rows matching molecule since date.

Get json data for n rows matching molecule since date.

Get data added/retracted since a human point in time (a java.util.Date).

// Transact 3 times (`inst` retrieves transaction time/Date from tx report)
val date1 = Person.name("Ann").save.inst
val date2 = Person.name("Ben").save.inst
val date3 = Person.name("Cay").save.inst

// Current values
Person.name.get === List("Ann", "Ben", "Cay")

// Ben and Cay added since date1
Person.name.getJsonSince(date1) ===
  """[
    |{"person.name": "Ben"},
    |{"person.name": "Cay"}
    |]""".stripMargin

// Ben and Cay added since date1 - only n (1) rows returned
Person.name.getJsonSince(date1, 1) ===
  """[
    |{"person.name": "Ben"}
    |]""".stripMargin

date: java.util.Date
n: Int Number of rows returned
conn: Implicit Conn value in scope
returns: String of json

Definition Classes: GetJson
See also: Manual on since

def getJsonSince(date: Date)(implicit conn: Conn): String

Get json data for all rows matching molecule since date.

Get json data for all rows matching molecule since date.

Get data added/retracted since a human point in time (a java.util.Date).

// Transact 3 times (`inst` retrieves transaction time/Date from tx report)
val date1 = Person.name("Ann").save.inst
val date2 = Person.name("Ben").save.inst
val date3 = Person.name("Cay").save.inst

// Current values
Person.name.get === List("Ann", "Ben", "Cay")

// Ben and Cay added since date1
Person.name.getJsonSince(date1) ===
  """[
    |{"person.name": "Ben"},
    |{"person.name": "Cay"}
    |]""".stripMargin

// Cay added since date2
Person.name.getJsonSince(date2) ===
  """[
    |{"person.name": "Cay"}
    |]""".stripMargin

// Nothing added since date3
Person.name.getJsonSince(date3) === ""

date: java.util.Date
conn: Implicit Conn value in scope
returns: String of json

Definition Classes: GetJson
See also: Manual on since

def getJsonSince(tx: TxReport, n: Int)(implicit conn: Conn): String

Get json data for n rows matching molecule since tx.

Get json data for n rows matching molecule since tx.

Datomic's internal since can take a transaction entity id as argument to retrieve a database value since that transaction (excluding the transaction itself).

Instead of supplying the transaction entity id, in Molecule we supply a TxReport that contains the transaction entity id (which is used as argument to Datomic internally). This is more convenient when using Molecule since we get a TxReport from transaction operations like get, update, retract etc.

// Get tx reports for 3 transactions
val tx1 = Person.name("Ann").save
val tx2 = Person.name("Ben").save
val tx3 = Person.name("Cay").save

// Current values
Person.name.get === List("Ann", "Ben", "Cay")

// Ben and Cay added since tx1
Person.name.getJsonSince(tx1) ===
  """[
    |{"person.name": "Ben"},
    |{"person.name": "Cay"}
    |]""".stripMargin

// Ben and Cay added since tx1 - only n (1) rows returned
Person.name.getJsonSince(tx1, 1) ===
  """[
    |{"person.name": "Ben"}
    |]""".stripMargin

tx: TxReport (returned from all molecule transaction operations)
n: Int Number of rows returned
conn: Implicit Conn value in scope
returns: String of json

Definition Classes: GetJson
See also: Manual on getAsOf

def getJsonSince(tx: TxReport)(implicit conn: Conn): String

Get json data for all rows matching molecule since tx.

Get json data for all rows matching molecule since tx.

Datomic's internal since can take a transaction entity id as argument to retrieve a database value since that transaction (excluding the transaction itself).

Instead of supplying the transaction entity id, in Molecule we supply a TxReport that contains the transaction entity id (which is used as argument to Datomic internally). This is more convenient when using Molecule since we get a TxReport from transaction operations like get, update, retract etc.

// Get tx reports for 3 transactions
val tx1 = Person.name("Ann").save
val tx2 = Person.name("Ben").save
val tx3 = Person.name("Cay").save

// Current values
Person.name.get === List("Ann", "Ben", "Cay")

// Ben and Cay added since tx1
Person.name.getJsonSince(tx1) ===
  """[
    |{"person.name": "Ben"},
    |{"person.name": "Cay"}
    |]""".stripMargin

// Cay added since tx2
Person.name.getJsonSince(tx2) ===
  """[
    |{"person.name": "Cay"}
    |]""".stripMargin

// Nothing added since tx3
Person.name.getJsonSince(tx3) === ""

tx: TxReport (returned from all molecule transaction operations)
conn: Implicit Conn value in scope
returns: String of json

Definition Classes: GetJson
See also: Manual on getAsOf

def getJsonSince(t: Long, n: Int)(implicit conn: Conn): String

Get json data for n rows matching molecule since transaction time t.

Get json data for n rows matching molecule since transaction time t.

Transaction time t is an auto-incremented transaction number assigned internally by Datomic.

t can for instance be retrieved by calling t on the tx report returned from transactional operations and then be used to get data since that point in time (excluding that transaction):

// 3 transaction times `t`
val t1 = Person.name("Ann").save.t
val t2 = Person.name("Ben").save.t
val t3 = Person.name("Cay").save.t

// Current values
Person.name.get === List("Ann", "Ben", "Cay")

// Ben and Cay added since transaction time t 1028
Person.name.getJsonSince(t1) ===
  """[
    |{"person.name": "Ben"},
    |{"person.name": "Cay"}
    |]""".stripMargin

// Ben and Cay added since transaction time t 1028 - only n (1) rows returned
Person.name.getJsonSince(t1, 1) ===
  """[
    |{"person.name": "Ben"}
    |]""".stripMargin

t: Transaction time t
n: Int Number of rows returned
conn: Implicit Conn value in scope
returns: String of json

Definition Classes: GetJson
See also: Manual on getAsOf

def getJsonSince(t: Long)(implicit conn: Conn): String

Get json data for all rows matching molecule since transaction time t.

Get json data for all rows matching molecule since transaction time t.

Transaction time t is an auto-incremented transaction number assigned internally by Datomic.

t can for instance be retrieved by calling t on the tx report returned from transactional operations and then be used to get data since that point in time (excluding that transaction):

// 3 transaction times `t`
val t1 = Person.name("Ann").save.t
val t2 = Person.name("Ben").save.t
val t3 = Person.name("Cay").save.t

// Current values
Person.name.get === List("Ann", "Ben", "Cay")

// Ben and Cay added since transaction time t 1028
Person.name.getJsonSince(t1) ===
  """[
    |{"person.name": "Ben"},
    |{"person.name": "Cay"}
    |]""".stripMargin

// Cay added since transaction time t 1030
Person.name.getJsonSince(t2) ===
  """[
    |{"person.name": "Cay"}
    |]""".stripMargin

// Nothing added since transaction time t 1032
Person.name.getJsonSince(t3) === ""

t: Transaction time t
conn: Implicit Conn value in scope
returns: String of json

Definition Classes: GetJson
See also: Manual on getAsOf

def getJsonWith(txData: List[_], n: Int)(implicit conn: Conn): String

Get json data for n rows matching molecule with applied raw transaction data.

Get json data for n rows matching molecule with applied raw transaction data.

Apply raw transaction data to in-memory "branch" of db without affecting db to see how it would then look:

// Live size of Person db
Person.name.get.size === 150

// Read some transaction data from file
val data_rdr2 = new FileReader("examples/resources/seattle/seattle-data1a.dtm")
val newDataTx = Util.readAll(data_rdr2).get(0).asInstanceOf[java.util.List[Object]]

// Imagine future db - 100 persons would be added, apparently
Person.name.getJsonWith(newDataTx).size === 250

// Imagine future db - Let's just take 10
Person.name.getJsonWith(newDataTx, 10).size === 10

txData: Raw transaction data as java.util.List[Object]
n: Int Number of rows returned
conn: Implicit Conn value in scope
returns: java.util.Collection[java.util.List[AnyRef]]

Definition Classes: GetJson
See also: Manual

def getJsonWith(txData: List[_])(implicit conn: Conn): String

Get json data for all rows matching molecule with applied raw transaction data.

Get json data for all rows matching molecule with applied raw transaction data.

Apply raw transaction data to in-memory "branch" of db without affecting db to see how it would then look:

// Live size of Person db
Person.name.get.size === 150

// Read some transaction data from file
val data_rdr2 = new FileReader("examples/resources/seattle/seattle-data1a.dtm")
val newDataTx = Util.readAll(data_rdr2).get(0).asInstanceOf[java.util.List[Object]]

// Imagine future db - 100 persons would be added, apparently
Person.name.getJsonWith(newDataTx).size === 250

txData: Raw transaction data as java.util.List[Object]
conn: Implicit Conn value in scope
returns: java.util.Collection[java.util.List[AnyRef]]

Definition Classes: GetJson
See also: Manual

def getJsonWith(n: Int, txMolecules: Seq[Seq[Statement]]*)(implicit conn: Conn): String

Get json data for all rows matching molecule with applied molecule transaction data.

Get json data for all rows matching molecule with applied molecule transaction data.

Apply one or more molecule transactions to in-memory "branch" of db without affecting db to see how it would then look:

// Current state
val List(ben, liz) = Person.name.likes.insert(
  ("Ben", "pasta"),
  ("Liz", "pizza")
).eids

// Test multiple transactions
Person.name.likes.getJsonWith(
  Person(ben).likes("sushi").getUpdateTx,
  Person(liz).likes("cake").getUpdateTx
) ===
  """[
    |{"person.name": "Ben", "person.likes": "sushi"},
    |{"person.name": "Liz", "person.likes": "cake"}
    |]""".stripMargin

// Same as above, but only n (1) rows returned:
Person.name.likes.getJsonWith(
  1
  Person(ben).likes("sushi").getUpdateTx,
  Person(liz).likes("cake").getUpdateTx
) ===
  """[
    |{"person.name": "Ben", "person.likes": "sushi"}
    |]""".stripMargin

Multiple transactions can be applied to test more complex what-if scenarios!

txMolecules: Transaction statements from applied Molecules with test data
conn: Implicit Conn value in scope
returns: String of json

Definition Classes: GetJson
See also: Manual

def getJsonWith(txMolecules: Seq[Seq[Statement]]*)(implicit conn: Conn): String

Get json data for all rows matching molecule with applied molecule transaction data.

Get json data for all rows matching molecule with applied molecule transaction data.

Apply one or more molecule transactions to in-memory "branch" of db without affecting db to see how it would then look:

// Current state
val ben = Person.name("Ben").likes("pasta").save.eid

// Base data
Person.name.likes.getJsonWith(
  // apply imaginary transaction data
  Person(ben).likes("sushi").getUpdateTx
) ===
  """[
    |{"person.name": "Ben", "person.likes": "sushi"}
    |]""".stripMargin

// Current state is still the same
Person.name.likes.get === List(("Ben", "pasta"))

Multiple transactions can be applied to test more complex what-if scenarios!

txMolecules: Transaction statements from applied Molecules with test data
conn: Implicit Conn value in scope
returns: String of json

Definition Classes: GetJson
See also: Manual

def getRaw(n: Int)(implicit conn: Conn): Collection[List[AnyRef]]

Get java.util.Collection of n untyped rows matching molecule.

Person.name.age.getRaw(1).toString === """[["Ben" 42]]"""

n: Number of rows
conn: Implicit Conn value in scope
returns: java.util.Collection[java.util.List[AnyRef]]

Definition Classes: GetRaw

def getRaw(implicit conn: Conn): Collection[List[AnyRef]]

Get java.util.Collection of all untyped rows matching molecule.

Person.name.age.getRaw.toString === """[["Ben" 42], ["Liz" 37]]"""

conn: Implicit Conn value in scope
returns: java.util.Collection[java.util.List[AnyRef]]

Definition Classes: GetRaw

def getRawAsOf(date: Date, n: Int)(implicit conn: Conn): Collection[List[AnyRef]]

Get java.util.Collection of n untyped rows matching molecule as of date.

Get java.util.Collection of n untyped rows matching molecule as of date.

Call getRawAsOf when data doesn't need to be type-casted. Datomic's raw data is returned as-is.

Get data at a human point in time (a java.util.Date).

val beforeInsert = new java.util.Date

// Insert
val tx1 = Person.name.age insert List(
  ("Ben", 42),
  ("Liz", 37),
)
val ben = tx1.eid
val afterInsert = new java.util.Date

// Update
val tx2 = Person(ben).age(43).update
val afterUpdate = new java.util.Date

// Retract
val tx3 = ben.retract
val afterRetract = new java.util.Date

// Get all rows of raw data as of beforeInsert
Person.name.age.getRawAsOf(beforeInsert).toString === """[]"""

// Get all rows of raw data as of afterInsert
Person.name.age.getRawAsOf(afterInsert).toString === """[["Liz" 37], ["Ben" 42]]"""

// Get n (1) rows of raw data as of afterInsert
Person.name.age.getRawAsOf(afterInsert, 1).toString === """[["Liz" 37]]"""

date: java.util.Date
n: Int Number of rows returned
conn: Implicit Conn value in scope
returns: java.util.Collection[java.util.List[AnyRef]]

Definition Classes: GetRaw
See also: Manual on getAsOf

def getRawAsOf(date: Date)(implicit conn: Conn): Collection[List[AnyRef]]

Get java.util.Collection of all untyped rows matching molecule as of date.

Get java.util.Collection of all untyped rows matching molecule as of date.

Call getRawAsOf when data doesn't need to be type-casted. Datomic's raw data is returned as-is.

Get data at a human point in time (a java.util.Date).

val beforeInsert = new java.util.Date

// Insert
val tx1 = Person.name.age insert List(
  ("Ben", 42),
  ("Liz", 37),
)
val ben = tx1.eid
val afterInsert = new java.util.Date

// Update
val tx2 = Person(ben).age(43).update
val afterUpdate = new java.util.Date

// Retract
val tx3 = ben.retract
val afterRetract = new java.util.Date

// Get raw data as of beforeInsert
Person.name.age.getRawAsOf(beforeInsert).toString === """[]"""

// Get raw data as of afterInsert
Person.name.age.getRawAsOf(afterInsert).toString === """[["Liz" 37], ["Ben" 42]]"""

// Get raw data as of afterUpdate
Person.name.age.getRawAsOf(afterUpdate).toString === """[["Liz" 37], ["Ben" 43]]""" // Ben now 43

// Get raw data as of afterRetract
Person.name.age.getRawAsOf(afterRetract).toString === """[["Liz" 37]]""" // Ben gone

date: java.util.Date
conn: Implicit Conn value in scope
returns: java.util.Collection[java.util.List[AnyRef]]

Definition Classes: GetRaw
See also: Manual on getAsOf

def getRawAsOf(tx: TxReport, n: Int)(implicit conn: Conn): Collection[List[AnyRef]]

Get java.util.Collection of n untyped rows matching molecule as of tx.

Get java.util.Collection of n untyped rows matching molecule as of tx.

The Array is only populated with n rows of type-casted tuples. Call getRawAsOf when data doesn't need to be type-casted. Datomic's raw data is returned as-is.

Datomic's internal asOf method can take a transaction entity id as argument to retrieve a database value as of that transaction (including).

Instead of supplying the transaction entity id, in Molecule we supply a TxReport that contains the transaction entity id (which is used as argument to Datomic internally). This is more convenient when using Molecule since we get a TxReport from transaction operations like get, update, retract etc.

// Insert (tx report 1)
val tx1 = Person.name.age insert List(
  ("Ben", 42),
  ("Liz", 37),
)
val ben = tx1.eid

// Update (tx report 2)
val tx2 = Person(ben).age(43).update

// Retract (tx report 3)
val tx3 = ben.retract

// Get all rows of raw data as of tx1 (after insert)
Person.name.age.getRawAsOf(tx1).toString === """[["Liz" 37], ["Ben" 42]]"""

// Get n (1) rows of raw data as of tx1 (after insert)
Person.name.age.getRawAsOf(tx1, 1).toString === """[["Liz" 37]]"""

tx: TxReport (returned from all molecule transaction operations)
n: Int Number of rows returned
conn: Implicit Conn value in scope
returns: java.util.Collection[java.util.List[AnyRef]]

Definition Classes: GetRaw
See also: Manual on getAsOf

def getRawAsOf(tx: TxReport)(implicit conn: Conn): Collection[List[AnyRef]]

Get java.util.Collection of all untyped rows matching molecule as of tx.

Call getRawAsOf when data doesn't need to be type-casted. Datomic's raw data is returned as-is.

Datomic's internal asOf method can take a transaction entity id as argument to retrieve a database value as of that transaction (including).

Instead of supplying the transaction entity id, in Molecule we supply a TxReport that contains the transaction entity id (which is used as argument to Datomic internally). This is more convenient when using Molecule since we get a TxReport from transaction operations like get, update, retract etc.

// Insert (tx report 1)
val tx1 = Person.name.age insert List(
  ("Ben", 42),
  ("Liz", 37),
)
val ben = tx1.eid

// Update (tx report 2)
val tx2 = Person(ben).age(43).update

// Retract (tx report 3)
val tx3 = ben.retract

// Get raw data as of tx1 (after insert)
Person.name.age.getRawAsOf(tx1).toString === """[["Liz" 37], ["Ben" 42]]"""

// Get raw data as of tx2 (after update)
Person.name.age.getRawAsOf(tx2).toString === """[["Liz" 37], ["Ben" 43]]""" // Ben now 43

// Get raw data as of tx3 (after retract)
Person.name.age.getRawAsOf(tx3).toString === """[["Liz" 37]]""" // Ben gone

tx: TxReport (returned from all molecule transaction operations)
conn: Implicit Conn value in scope
returns: java.util.Collection[java.util.List[AnyRef]]

Definition Classes: GetRaw
See also: Manual on getAsOf

def getRawAsOf(t: Long, n: Int)(implicit conn: Conn): Collection[List[AnyRef]]

Get java.util.Collection of n untyped rows matching molecule as of transaction time t.

Get java.util.Collection of n untyped rows matching molecule as of transaction time t.

Call getRawAsOf when data doesn't need to be type-casted. Datomic's raw data is returned as-is.

Transaction time t is an auto-incremented transaction number assigned internally by Datomic.

t can for instance be retrieved in a getHistory call for an attribute and then be used to get data as of that point in time (including that transaction):

// Insert (t 1028)
val List(ben, liz) = Person.name.age insert List(
  ("Ben", 42),
  ("Liz", 37),
) eids

// Update (t 1031)
Person(ben).age(43).update

// History of Ben
Person(ben).age.t.op.getHistory.sortBy(r => (r._2, r._3)) === List(
  (42, 1028, true),  // Insert:  42 asserted
  (42, 1031, false), // Update:  42 retracted
  (43, 1031, true),  //          43 asserted
)

// Get all rows of raw data as of transaction t 1031 (after update)
Person.name.age.getRawAsOf(1028).toString === """[["Ben" 43], ["Liz" 37]]"""

// Get n (1) rows of raw data as of transaction t 1031 (after update)
Person.name.age.getRawAsOf(1031, 1).toString === """[["Ben" 43]]"""

t: Transaction time t
n: Int Number of rows returned
conn: Implicit Conn value in scope
returns: java.util.Collection[java.util.List[AnyRef]]

Definition Classes: GetRaw
See also: Manual on getAsOf

def getRawAsOf(t: Long)(implicit conn: Conn): Collection[List[AnyRef]]

Get java.util.Collection of all untyped rows matching molecule as of transaction time t.

Get java.util.Collection of all untyped rows matching molecule as of transaction time t.

Call getRawAsOf when data doesn't need to be type-casted. Datomic's raw data is returned as-is.

Transaction time t is an auto-incremented transaction number assigned internally by Datomic.

t can for instance be retrieved in a getHistory call for an attribute and then be used to get data as of that point in time (including that transaction):

// Insert (t 1028)
val List(ben, liz) = Person.name.age insert List(
  ("Ben", 42),
  ("Liz", 37),
) eids

// Update (t 1031)
Person(ben).age(43).update

// Retract (t 1032)
ben.retract

// History of Ben
Person(ben).age.t.op.getHistory.sortBy(r => (r._2, r._3)) === List(
  (42, 1028, true),  // Insert:  42 asserted
  (42, 1031, false), // Update:  42 retracted
  (43, 1031, true),  //          43 asserted
  (43, 1032, false)  // Retract: 43 retracted
)

// Get raw data as of transaction t 1028 (after insert)
Person.name.age.getRawAsOf(1028).toString === """[["Ben" 42], ["Liz" 37]]"""

// Get raw data as of transaction t 1031 (after update)
Person.name.age.getRawAsOf(1031).toString === """[["Ben" 43], ["Liz" 37]]""" // Ben now 43

// Get raw data as of transaction t 1032 (after retract)
Person.name.age.getRawAsOf(1032).toString === """[["Liz" 37]]""" // Ben gone

t: Transaction time t
conn: Implicit Conn value in scope
returns: java.util.Collection[java.util.List[AnyRef]]

Definition Classes: GetRaw
See also: Manual on getAsOf

def getRawSince(date: Date, n: Int)(implicit conn: Conn): Collection[List[AnyRef]]

Get java.util.Collection of n untyped rows matching molecule since date.

Get java.util.Collection of n untyped rows matching molecule since date.

Call getRawSince when data doesn't need to be type-casted. Datomic's raw data is returned as-is.

Get data added/retracted since a human point in time (a java.util.Date).

// Transact 3 times (`inst` retrieves transaction time from tx report)
val date1 = Person.name("Ann").save.inst
val date2 = Person.name("Ben").save.inst
val date3 = Person.name("Cay").save.inst

// Current values
Person.name.get === List("Ann", "Ben", "Cay")

// Ben and Cay added since date1
Person.name.getRawSince(date1).toString === """[["Ben"], ["Cay"]]"""

// Ben and Cay added since date1 - only n (1) rows returned
Person.name.getRawSince(date1, 1).toString === """[["Ben"]]"""

date: java.util.Date
n: Int Number of rows returned
conn: Implicit Conn value in scope
returns: java.util.Collection[java.util.List[AnyRef]]

Definition Classes: GetRaw
See also: Manual on getAsOf

def getRawSince(date: Date)(implicit conn: Conn): Collection[List[AnyRef]]

Get java.util.Collection of all untyped rows matching molecule since date.

Get java.util.Collection of all untyped rows matching molecule since date.

Call getRawSince when data doesn't need to be type-casted. Datomic's raw data is returned as-is.

Get data added/retracted since a human point in time (a java.util.Date).

// Transact 3 times (`inst` retrieves transaction time from tx report)
val date1 = Person.name("Ann").save.inst
val date2 = Person.name("Ben").save.inst
val date3 = Person.name("Cay").save.inst

// Current values
Person.name.get === List("Ann", "Ben", "Cay")

// Ben and Cay added since date1
Person.name.getRawSince(date1).toString === """[["Ben"], ["Cay"]]"""

// Cay added since date2
Person.name.getRawSince(date2).toString === """[["Cay"]]"""

// Nothing added since date3
Person.name.getRawSince(date3).toString === """[]"""

date: java.util.Date
conn: Implicit Conn value in scope
returns: java.util.Collection[java.util.List[AnyRef]]

Definition Classes: GetRaw
See also: Manual on getAsOf

def getRawSince(tx: TxReport, n: Int)(implicit conn: Conn): Collection[List[AnyRef]]

Get java.util.Collection of n untyped rows matching molecule since tx.

Get java.util.Collection of n untyped rows matching molecule since tx.

Call getRawSince when data doesn't need to be type-casted. Datomic's raw data is returned as-is.

Datomic's internal since method can take a transaction entity id as argument to retrieve a database value since that transaction (excluding).

Instead of supplying the transaction entity id, in Molecule we supply a TxReport that contains the transaction entity id (which is used as argument to Datomic internally). This is more convenient when using Molecule since we get a TxReport from transaction operations like get, update, retract etc.

// Get tx reports for 3 transactions
val tx1 = Person.name("Ann").save
val tx2 = Person.name("Ben").save
val tx3 = Person.name("Cay").save

// Current values
Person.name.get === List("Ann", "Ben", "Cay")

// Ben and Cay added since tx1
Person.name.getRawSince(tx1).toString === """[["Ben"], ["Cay"]]"""

// Ben and Cay added since tx1 - only n (1) rows returned
Person.name.getRawSince(tx1, 1).toString === """[["Ben"]]"""

tx: TxReport (returned from all molecule transaction operations)
n: Int Number of rows returned
conn: Implicit Conn value in scope
returns: java.util.Collection[java.util.List[AnyRef]]

Definition Classes: GetRaw
See also: Manual on getAsOf

def getRawSince(tx: TxReport)(implicit conn: Conn): Collection[List[AnyRef]]

Get java.util.Collection of all untyped rows matching molecule since tx.

Get java.util.Collection of all untyped rows matching molecule since tx.

Call getRawSince when data doesn't need to be type-casted. Datomic's raw data is returned as-is.

Datomic's internal since method can take a transaction entity id as argument to retrieve a database value since that transaction (excluding).

Instead of supplying the transaction entity id, in Molecule we supply a TxReport that contains the transaction entity id (which is used as argument to Datomic internally). This is more convenient when using Molecule since we get a TxReport from transaction operations like get, update, retract etc.

// Get tx reports for 3 transactions
val tx1 = Person.name("Ann").save
val tx2 = Person.name("Ben").save
val tx3 = Person.name("Cay").save

// Current values
Person.name.get === List("Ann", "Ben", "Cay")

// Ben and Cay added since tx1
Person.name.getRawSince(tx1).toString === """[["Ben"], ["Cay"]]"""

// Cay added since tx2
Person.name.getRawSince(tx2).toString === """[["Cay"]]"""

// Nothing added since tx3
Person.name.getRawSince(tx3).toString === """[]"""

tx: TxReport (returned from all molecule transaction operations)
conn: Implicit Conn value in scope
returns: java.util.Collection[java.util.List[AnyRef]]

Definition Classes: GetRaw
See also: Manual on getAsOf

def getRawSince(t: Long, n: Int)(implicit conn: Conn): Collection[List[AnyRef]]

Get java.util.Collection of n untyped rows matching molecule since transaction time t.

Get java.util.Collection of n untyped rows matching molecule since transaction time t.

Call getRawSince when data doesn't need to be type-casted. Datomic's raw data is returned as-is.

Transaction time t is an auto-incremented transaction number assigned internally by Datomic.

t can for instance be retrieved calling t on the tx report returned from transactional operations and then be used to get data since that point in time (excluding that transaction):

// 3 transaction times `t`
val t1 = Person.name("Ann").save.t
val t2 = Person.name("Ben").save.t
val t3 = Person.name("Cay").save.t

// Current values as Iterable
Person.name.get === List("Ann", "Ben", "Cay")

// Ben and Cay added since transaction time t1
Person.name.getRawSince(t1).toString === """[["Ben"], ["Cay"]]"""

// Ben and Cay added since transaction time t1 - only n (1) rows returned
Person.name.getRawSince(t1).toString === """[["Ben"]]"""

t: Transaction time t
n: Int Number of rows returned
conn: Implicit Conn value in scope
returns: java.util.Collection[java.util.List[AnyRef]]

Definition Classes: GetRaw
See also: Manual on getAsOf

def getRawSince(t: Long)(implicit conn: Conn): Collection[List[AnyRef]]

Get java.util.Collection of all untyped rows matching molecule since transaction time t.

Get java.util.Collection of all untyped rows matching molecule since transaction time t.

Call getRawSince when data doesn't need to be type-casted. Datomic's raw data is returned as-is.

Transaction time t is an auto-incremented transaction number assigned internally by Datomic.

t can for instance be retrieved calling t on the tx report returned from transactional operations and then be used to get data since that point in time (excluding that transaction):

// 3 transaction times `t`
val t1 = Person.name("Ann").save.t
val t2 = Person.name("Ben").save.t
val t3 = Person.name("Cay").save.t

// Current values as Iterable
Person.name.get === List("Ann", "Ben", "Cay")

// Ben and Cay added since transaction time t1
Person.name.getRawSince(t1).toString === """[["Ben"], ["Cay"]]"""

// Cay added since transaction time t2
Person.name.getRawSince(t2).toString === """[["Cay"]]"""

// Nothing added since transaction time t3
Person.name.getRawSince(t3).toString === """[]"""

t: Transaction time t
conn: Implicit Conn value in scope
returns: java.util.Collection[java.util.List[AnyRef]]

Definition Classes: GetRaw
See also: Manual on getAsOf

def getRawWith(txData: List[_], n: Int)(implicit conn: Conn): Collection[List[AnyRef]]

Get java.util.Collection of n untyped rows matching molecule with applied raw transaction data.

Get java.util.Collection of n untyped rows matching molecule with applied raw transaction data.

Apply raw transaction data to in-memory "branch" of db without affecting db to see how it would then look:

// Live size of Person db
Person.name.get.size === 150

// Read some transaction data from file
val data_rdr2 = new FileReader("examples/resources/seattle/seattle-data1a.dtm")
val newDataTx = Util.readAll(data_rdr2).get(0).asInstanceOf[java.util.List[Object]]

// Imagine future db - 100 persons would be added, apparently
Person.name.getRawWith(newDataTx).size === 250

// Imagine future db - Let's just take 10
Person.name.getRawWith(newDataTx, 10).size === 10

txData: Raw transaction data as java.util.List[Object]
n: Int Number of rows returned
conn: Implicit Conn value in scope
returns: java.util.Collection[java.util.List[AnyRef]]

Definition Classes: GetRaw
See also: Manual

def getRawWith(txData: List[_])(implicit conn: Conn): Collection[List[AnyRef]]

Get java.util.Collection of all untyped rows matching molecule with applied raw transaction data.

Get java.util.Collection of all untyped rows matching molecule with applied raw transaction data.

Apply raw transaction data to in-memory "branch" of db without affecting db to see how it would then look:

// Live size of Person db
Person.name.get.size === 150

// Read some transaction data from file
val data_rdr2 = new FileReader("examples/resources/seattle/seattle-data1a.dtm")
val newDataTx = Util.readAll(data_rdr2).get(0).asInstanceOf[java.util.List[Object]]

// Imagine future db - 100 persons would be added, apparently
Person.name.getRawWith(newDataTx).size === 250

txData: Raw transaction data as java.util.List[Object]
conn: Implicit Conn value in scope
returns: java.util.Collection[java.util.List[AnyRef]]

Definition Classes: GetRaw
See also: Manual

def getRawWith(n: Int, txMolecules: Seq[Seq[Statement]]*)(implicit conn: Conn): Collection[List[AnyRef]]

Get java.util.Collection of n untyped rows matching molecule with applied molecule transaction data.

Get java.util.Collection of n untyped rows matching molecule with applied molecule transaction data.

Apply one or more molecule transactions to in-memory "branch" of db without affecting db to see how it would then look:

// Current state
val List(ben, liz) = Person.name.likes.insert(
  ("Ben", "pasta"),
  ("Liz", "pizza")
).eids

// Test multiple transactions
Person.name.likes.getRawWith(
  Person(ben).likes("sushi").getUpdateTx,
  Person(liz).likes("cake").getUpdateTx
).toString === """[["Ben" "sushi"], ["Liz" "cake"]]"""

// Same as above, but only n (1) rows returned:
Person.name.likes.getRawWith(
  1
  Person(ben).likes("sushi").getUpdateTx,
  Person(liz).likes("cake").getUpdateTx
).toString === """[["Ben" "sushi"]]"""

Multiple transactions can be applied to test more complex what-if scenarios!

n: Int Number of rows returned
txMolecules: Transaction statements from applied Molecules with test data
conn: Implicit Conn value in scope
returns: java.util.Collection[java.util.List[AnyRef]]

Definition Classes: GetRaw
Note: Note how the n parameter has to come before the txMolecules vararg.
See also: Manual

def getRawWith(txMolecules: Seq[Seq[Statement]]*)(implicit conn: Conn): Collection[List[AnyRef]]

Get java.util.Collection of all untyped rows matching molecule with applied molecule transaction data.

Get java.util.Collection of all untyped rows matching molecule with applied molecule transaction data.

Apply one or more molecule transactions to in-memory "branch" of db without affecting db to see how it would then look:

// Current state
val ben = Person.name("Ben").likes("pasta").save.eid

// Base data
Person.name.likes.getRawWith(
  Person(ben).likes("sushi").getUpdateTx
).toString ==== """[["Ben" "sushi"]]"""

// Current state is still the same
Person.name.likes.get === List(("Ben", "pasta"))

Multiple transactions can be applied to test more complex what-if scenarios!

txMolecules: Transaction statements from applied Molecules with test data
conn: Implicit Conn value in scope
returns: java.util.Collection[java.util.List[AnyRef]]

Definition Classes: GetRaw
See also: Manual

def getSaveTx(implicit conn: Conn): Seq[Seq[Statement]]

Get transaction statements of a call to save on a molecule (without affecting the db).

conn: Implicit Conn value in scope
returns: Transaction statements

Definition Classes: Molecule

def getSince(date: Date, n: Int)(implicit conn: Conn, ev: ClassTag[(A, B, C, D, E, F, G, H, I)]): List[(A, B, C, D, E, F, G, H, I)]

Get List of n rows as tuples matching molecule since date.

Get List of n rows as tuples matching molecule since date.

Get data added/retracted since a human point in time (a java.util.Date).

// Transact 3 times (`inst` retrieves transaction time/Date from tx report)
val date1 = Person.name("Ann").save.inst
val date2 = Person.name("Ben").save.inst
val date3 = Person.name("Cay").save.inst

// Current values
Person.name.get === List("Ann", "Ben", "Cay")

// Ben and Cay added since date1
Person.name.getSince(date1) === List("Ben", "Cay")

// Ben and Cay added since date1 - only n (1) rows returned
Person.name.getSince(date1, 1) === List("Ben")

date: java.util.Date
n: Int Number of rows returned
conn: Implicit Conn value in scope
returns: List[Tpl] where Tpl is a tuple of data matching molecule

Definition Classes: GetList
See also: Manual on since

def getSince(date: Date)(implicit conn: Conn, ev: ClassTag[(A, B, C, D, E, F, G, H, I)]): List[(A, B, C, D, E, F, G, H, I)]

Get List of all rows as tuples matching molecule since date.

Get List of all rows as tuples matching molecule since date.

Get data added/retracted since a human point in time (a java.util.Date).

// Transact 3 times (`inst` retrieves transaction time/Date from tx report)
val date1 = Person.name("Ann").save.inst
val date2 = Person.name("Ben").save.inst
val date3 = Person.name("Cay").save.inst

// Current values
Person.name.get === List("Ann", "Ben", "Cay")

// Ben and Cay added since date1
Person.name.getSince(date1) === List("Ben", "Cay")

// Cay added since date2
Person.name.getSince(date2) === List("Cay")

// Nothing added since date3
Person.name.getSince(date3) === Nil

date: java.util.Date
conn: Implicit Conn value in scope
returns: List[Tpl] where Tpl is a tuple of data matching molecule

Definition Classes: GetList
See also: Manual on since

def getSince(tx: TxReport, n: Int)(implicit conn: Conn, ev: ClassTag[(A, B, C, D, E, F, G, H, I)]): List[(A, B, C, D, E, F, G, H, I)]

Get List of n rows as tuples matching molecule since tx.

Get List of n rows as tuples matching molecule since tx.

Datomic's internal since can take a transaction entity id as argument to retrieve a database value since that transaction (excluding the transaction itself).

Instead of supplying the transaction entity id, in Molecule we supply a TxReport that contains the transaction entity id (which is used as argument to Datomic internally). This is more convenient when using Molecule since we get a TxReport from transaction operations like get, update, retract etc.

// Get tx reports for 3 transactions
val tx1 = Person.name("Ann").save
val tx2 = Person.name("Ben").save
val tx3 = Person.name("Cay").save

// Current values
Person.name.get === List("Ann", "Ben", "Cay")

// Ben and Cay added since tx1
Person.name.getSince(tx1) === List("Ben", "Cay")

// Ben and Cay added since tx1 - only n (1) rows returned
Person.name.getSince(tx1, 1) === List("Ben")

tx: TxReport
n: Int Number of rows returned
conn: Implicit Conn value in scope
returns: List[Tpl] where Tpl is a tuple of data matching molecule

Definition Classes: GetList
See also: Manual on since

def getSince(tx: TxReport)(implicit conn: Conn, ev: ClassTag[(A, B, C, D, E, F, G, H, I)]): List[(A, B, C, D, E, F, G, H, I)]

Get List of all rows as tuples matching molecule since tx.

Get List of all rows as tuples matching molecule since tx.

Datomic's internal since can take a transaction entity id as argument to retrieve a database value since that transaction (excluding the transaction itself).

Instead of supplying the transaction entity id, in Molecule we supply a TxReport that contains the transaction entity id (which is used as argument to Datomic internally). This is more convenient when using Molecule since we get a TxReport from transaction operations like get, update, retract etc.

// Get tx reports for 3 transactions
val tx1 = Person.name("Ann").save
val tx2 = Person.name("Ben").save
val tx3 = Person.name("Cay").save

// Current values
Person.name.get === List("Ann", "Ben", "Cay")

// Ben and Cay added since tx1
Person.name.getSince(tx1) === List("Ben", "Cay")

// Cay added since tx2
Person.name.getSince(tx2) === List("Cay")

// Nothing added since tx3
Person.name.getSince(tx3) === Nil

tx: TxReport
conn: Implicit Conn value in scope
returns: List[Tpl] where Tpl is a tuple of data matching molecule

Definition Classes: GetList
See also: Manual on since

def getSince(t: Long, n: Int)(implicit conn: Conn, ev: ClassTag[(A, B, C, D, E, F, G, H, I)]): List[(A, B, C, D, E, F, G, H, I)]

Get List of n rows as tuples matching molecule since transaction time t.

Get List of n rows as tuples matching molecule since transaction time t.

Transaction time t is an auto-incremented transaction number assigned internally by Datomic.

t can for instance be retrieved by calling t on the tx report returned from transactional operations and then be used to get data since that point in time (excluding that transaction):

// 3 transaction times `t`
val t1 = Person.name("Ann").save.t
val t2 = Person.name("Ben").save.t
val t3 = Person.name("Cay").save.t

// Current values
Person.name.get === List("Ann", "Ben", "Cay")

// Ben and Cay added since transaction time t 1028
Person.name.getSince(t1) === List("Ben", "Cay")

// Ben and Cay added since transaction time t 1028 - only n (1) rows returned
Person.name.getSince(t1, 1) === List("Ben")

t: Transaction time t
n: Int Number of rows returned
conn: Implicit Conn value in scope
returns: List[Tpl] where Tpl is a tuple of data matching molecule

Definition Classes: GetList
See also: Manual on since

def getSince(t: Long)(implicit conn: Conn, ev: ClassTag[(A, B, C, D, E, F, G, H, I)]): List[(A, B, C, D, E, F, G, H, I)]

Get List of all rows as tuples matching molecule since transaction time t.

Get List of all rows as tuples matching molecule since transaction time t.

Transaction time t is an auto-incremented transaction number assigned internally by Datomic.

t can for instance be retrieved by calling t on the tx report returned from transactional operations and then be used to get data since that point in time (excluding that transaction):

// 3 transaction times `t`
val t1 = Person.name("Ann").save.t
val t2 = Person.name("Ben").save.t
val t3 = Person.name("Cay").save.t

// Current values
Person.name.get === List("Ann", "Ben", "Cay")

// Ben and Cay added since transaction time t 1028
Person.name.getSince(t1) === List("Ben", "Cay")

// Cay added since transaction time t 1030
Person.name.getSince(t2) === List("Cay")

// Nothing added since transaction time t 1032
Person.name.getSince(t3) === Nil

t: Transaction time t
conn: Implicit Conn value in scope
returns: List[Tpl] where Tpl is a tuple of data matching molecule

Definition Classes: GetList
See also: Manual on since

def getUpdateTx(implicit conn: Conn): Seq[Seq[Statement]]

Get transaction statements of a call to update on a molecule (without affecting the db).

conn: Implicit Conn value in scope

Definition Classes: Molecule

def getWith(txData: List[_], n: Int)(implicit conn: Conn, ev: ClassTag[(A, B, C, D, E, F, G, H, I)]): List[(A, B, C, D, E, F, G, H, I)]

Get List of n rows as tuples matching molecule with applied raw transaction data.

Get List of n rows as tuples matching molecule with applied raw transaction data.

Apply raw transaction data to in-memory "branch" of db without affecting db to see how it would then look:

// Live size of Person db
Person.name.get.size === 150

// Read some transaction data from file
val data_rdr2 = new FileReader("examples/resources/seattle/seattle-data1a.dtm")
val newDataTx = Util.readAll(data_rdr2).get(0).asInstanceOf[java.util.List[Object]]

// Imagine future db - 100 persons would be added, apparently
Person.name.getWith(newDataTx).size === 250

// Imagine future db - Let's just take 10
Person.name.getWith(newDataTx, 10).size === 10

txData: Raw transaction data as java.util.List[Object]
n: Int Number of rows returned
conn: Implicit Conn value in scope
returns: List[Tpl] where Tpl is a tuple of data matching molecule

Definition Classes: GetList
See also: Manual

def getWith(txData: List[_])(implicit conn: Conn, ev: ClassTag[(A, B, C, D, E, F, G, H, I)]): List[(A, B, C, D, E, F, G, H, I)]

Get List of all rows as tuples matching molecule with applied raw transaction data.

Get List of all rows as tuples matching molecule with applied raw transaction data.

Apply raw transaction data to in-memory "branch" of db without affecting db to see how it would then look:

// Live size of Person db
Person.name.get.size === 150

// Read some transaction data from file
val data_rdr2 = new FileReader("examples/resources/seattle/seattle-data1a.dtm")
val newDataTx = Util.readAll(data_rdr2).get(0).asInstanceOf[java.util.List[Object]]

// Imagine future db - 100 persons would be added, apparently
Person.name.getWith(newDataTx).size === 250

txData: Raw transaction data as java.util.List[Object]
conn: Implicit Conn value in scope
returns: List[Tpl] where Tpl is a tuple of data matching molecule

Definition Classes: GetList
See also: Manual

def getWith(n: Int, txMolecules: Seq[Seq[Statement]]*)(implicit conn: Conn, ev: ClassTag[(A, B, C, D, E, F, G, H, I)]): List[(A, B, C, D, E, F, G, H, I)]

Get List of n rows as tuples matching molecule with applied molecule transaction data.

Get List of n rows as tuples matching molecule with applied molecule transaction data.

Apply one or more molecule transactions to in-memory "branch" of db without affecting db to see how it would then look:

// Current state
val List(ben, liz) = Person.name.likes.insert(
  ("Ben", "pasta"),
  ("Liz", "pizza")
).eids

// Test multiple transactions
Person.name.likes.getWith(
  Person(ben).likes("sushi").getUpdateTx,
  Person(liz).likes("cake").getUpdateTx
) === List(
  ("Ben", "sushi")
  ("Liz", "cake")
)

// Same as above, but only n (1) rows returned:
Person.name.likes.getWith(
  1
  Person(ben).likes("sushi").getUpdateTx,
  Person(liz).likes("cake").getUpdateTx
) === List(
  ("Ben", "sushi")
)

n: Int Number of rows returned
txMolecules: Transaction statements from applied Molecules with test data
conn: Implicit Conn value in scope
returns: List[Tpl] where Tpl is a tuple of data matching molecule

Definition Classes: GetList
Note: Note how the n parameter has to come before the txMolecules vararg.
See also: Manual

def getWith(txMolecules: Seq[Seq[Statement]]*)(implicit conn: Conn, ev: ClassTag[(A, B, C, D, E, F, G, H, I)]): List[(A, B, C, D, E, F, G, H, I)]

Get List of all rows as tuples matching molecule with applied molecule transaction data.

Get List of all rows as tuples matching molecule with applied molecule transaction data.

Apply one or more molecule transactions to in-memory "branch" of db without affecting db to see how it would then look:

// Current state
val ben = Person.name("Ben").likes("pasta").save.eid

// Base data
Person.name.likes.getWith(
  // apply imaginary transaction data
  Person(ben).likes("sushi").getUpdateTx
) === List(
  // Effect: Ben would like sushi if tx was applied
  ("Ben", "sushi")
)

// Current state is still the same
Person.name.likes.get === List(("Ben", "pasta"))

Multiple transactions can be applied to test more complex what-if scenarios!

txMolecules: Transaction statements from applied Molecules with test data
conn: Implicit Conn value in scope
returns: List[Tpl] where Tpl is a tuple of data matching molecule

Definition Classes: GetList
See also: Manual

def hashCode(): Int

Definition Classes: AnyRef → Any
Annotations: @native()

final def isInstanceOf[T0]: Boolean

Definition Classes: Any

def jsonAggr(sb: StringBuilder, field: String, row: List[_], i: Int): StringBuilder

Attributes: protected
Definition Classes: JsonBuilder

def jsonAggrDate(sb: StringBuilder, field: String, row: List[_], i: Int): StringBuilder

Attributes: protected
Definition Classes: JsonBuilder

def jsonAggrLazySeq(sb: StringBuilder, field: String, row: List[_], i: Int): StringBuilder

Attributes: protected
Definition Classes: JsonBuilder

def jsonAggrLazySeqDate(sb: StringBuilder, field: String, row: List[_], i: Int): StringBuilder

Attributes: protected
Definition Classes: JsonBuilder

def jsonAggrLazySeqQuoted(sb: StringBuilder, field: String, row: List[_], i: Int): StringBuilder

Attributes: protected
Definition Classes: JsonBuilder

def jsonAggrLazySeqToString(sb: StringBuilder, field: String, row: List[_], i: Int): StringBuilder

Attributes: protected
Definition Classes: JsonBuilder

def jsonAggrListLazySeq(sb: StringBuilder, field: String, row: List[_], i: Int): StringBuilder

Attributes: protected
Definition Classes: JsonBuilder

def jsonAggrListLazySeqDate(sb: StringBuilder, field: String, row: List[_], i: Int): StringBuilder

Attributes: protected
Definition Classes: JsonBuilder

def jsonAggrListLazySeqQuoted(sb: StringBuilder, field: String, row: List[_], i: Int): StringBuilder

Attributes: protected
Definition Classes: JsonBuilder

def jsonAggrListLazySeqToString(sb: StringBuilder, field: String, row: List[_], i: Int): StringBuilder

Attributes: protected
Definition Classes: JsonBuilder

def jsonAggrListVector(sb: StringBuilder, field: String, row: List[_], i: Int): StringBuilder

Attributes: protected
Definition Classes: JsonBuilder

def jsonAggrListVectorDate(sb: StringBuilder, field: String, row: List[_], i: Int): StringBuilder

Attributes: protected
Definition Classes: JsonBuilder

def jsonAggrListVectorQuoted(sb: StringBuilder, field: String, row: List[_], i: Int): StringBuilder

Attributes: protected
Definition Classes: JsonBuilder

def jsonAggrListVectorToString(sb: StringBuilder, field: String, row: List[_], i: Int): StringBuilder

Attributes: protected
Definition Classes: JsonBuilder

def jsonAggrQuoted(sb: StringBuilder, field: String, row: List[_], i: Int): StringBuilder

Attributes: protected
Definition Classes: JsonBuilder

def jsonAggrToString(sb: StringBuilder, field: String, row: List[_], i: Int): StringBuilder

Attributes: protected
Definition Classes: JsonBuilder

def jsonAggrVector(sb: StringBuilder, field: String, row: List[_], i: Int): StringBuilder

Attributes: protected
Definition Classes: JsonBuilder

def jsonAggrVectorDate(sb: StringBuilder, field: String, row: List[_], i: Int): StringBuilder

Attributes: protected
Definition Classes: JsonBuilder

def jsonAggrVectorQuoted(sb: StringBuilder, field: String, row: List[_], i: Int): StringBuilder

Attributes: protected
Definition Classes: JsonBuilder

def jsonAggrVectorToString(sb: StringBuilder, field: String, row: List[_], i: Int): StringBuilder

Attributes: protected
Definition Classes: JsonBuilder

def jsonMany(sb: StringBuilder, field: String, row: List[_], i: Int): StringBuilder

Attributes: protected
Definition Classes: JsonBuilder

def jsonManyDate(sb: StringBuilder, field: String, row: List[_], i: Int): StringBuilder

Attributes: protected
Definition Classes: JsonBuilder

def jsonManyQuoted(sb: StringBuilder, field: String, row: List[_], i: Int): StringBuilder

Attributes: protected
Definition Classes: JsonBuilder

def jsonManyToString(sb: StringBuilder, field: String, row: List[_], i: Int): StringBuilder

Attributes: protected
Definition Classes: JsonBuilder

def jsonMap(sb: StringBuilder, field: String, row: List[_], i: Int): StringBuilder

Attributes: protected
Definition Classes: JsonBuilder

def jsonMapDate(sb: StringBuilder, field: String, row: List[_], i: Int): StringBuilder

Attributes: protected
Definition Classes: JsonBuilder

def jsonMapQuoted(sb: StringBuilder, field: String, row: List[_], i: Int): StringBuilder

Attributes: protected
Definition Classes: JsonBuilder

def jsonOne(sb: StringBuilder, field: String, row: List[_], i: Int): StringBuilder

Attributes: protected
Definition Classes: JsonBuilder

def jsonOneAny(sb: StringBuilder, field: String, row: List[_], i: Int): StringBuilder

Attributes: protected
Definition Classes: JsonBuilder

def jsonOneDate(sb: StringBuilder, field: String, row: List[_], i: Int): StringBuilder

Attributes: protected
Definition Classes: JsonBuilder

def jsonOneQuoted(sb: StringBuilder, field: String, row: List[_], i: Int): StringBuilder

Attributes: protected
Definition Classes: JsonBuilder

def jsonOneToString(sb: StringBuilder, field: String, row: List[_], i: Int): StringBuilder

Attributes: protected
Definition Classes: JsonBuilder

def jsonOptMany(sb: StringBuilder, field: String, row: List[_], i: Int): StringBuilder

Attributes: protected
Definition Classes: JsonBuilder

def jsonOptManyDate(sb: StringBuilder, field: String, row: List[_], i: Int): StringBuilder

Attributes: protected
Definition Classes: JsonBuilder

def jsonOptManyEnum(sb: StringBuilder, field: String, row: List[_], i: Int): StringBuilder

Attributes: protected
Definition Classes: JsonBuilder

def jsonOptManyQuoted(sb: StringBuilder, field: String, row: List[_], i: Int): StringBuilder

Attributes: protected
Definition Classes: JsonBuilder

def jsonOptManyToString(sb: StringBuilder, field: String, row: List[_], i: Int): StringBuilder

Attributes: protected
Definition Classes: JsonBuilder

def jsonOptMap(sb: StringBuilder, field: String, row: List[_], i: Int): StringBuilder

Attributes: protected
Definition Classes: JsonBuilder

def jsonOptMapDate(sb: StringBuilder, field: String, row: List[_], i: Int): StringBuilder

Attributes: protected
Definition Classes: JsonBuilder

def jsonOptMapQuoted(sb: StringBuilder, field: String, row: List[_], i: Int): StringBuilder

Attributes: protected
Definition Classes: JsonBuilder

def jsonOptOne(sb: StringBuilder, field: String, row: List[_], i: Int): StringBuilder

Attributes: protected
Definition Classes: JsonBuilder

def jsonOptOneDate(sb: StringBuilder, field: String, row: List[_], i: Int): StringBuilder

Attributes: protected
Definition Classes: JsonBuilder

def jsonOptOneEnum(sb: StringBuilder, field: String, row: List[_], i: Int): StringBuilder

Attributes: protected
Definition Classes: JsonBuilder

def jsonOptOneQuoted(sb: StringBuilder, field: String, row: List[_], i: Int): StringBuilder

Attributes: protected
Definition Classes: JsonBuilder

def jsonOptOneToString(sb: StringBuilder, field: String, row: List[_], i: Int): StringBuilder

Attributes: protected
Definition Classes: JsonBuilder

final def ne(arg0: AnyRef): Boolean

Definition Classes: AnyRef

final def notify(): Unit

Definition Classes: AnyRef
Annotations: @native()

final def notifyAll(): Unit

Definition Classes: AnyRef
Annotations: @native()

final def o(opt: Option[Any]): String

Attributes: protected
Definition Classes: Helpers

def pair(sb: StringBuilder, field: String, value: Any): StringBuilder

Attributes: protected
Definition Classes: JsonBuilder

def quote(sb: StringBuilder, s: String): StringBuilder

Attributes: protected
Definition Classes: JsonBuilder

def quotedPair(sb: StringBuilder, field: String, value: String): StringBuilder

Attributes: protected
Definition Classes: JsonBuilder

def row2json(sb: StringBuilder, row: List[AnyRef]): StringBuilder

Attributes: protected
Definition Classes: JsonBuilder

def save(implicit conn: Conn): TxReport

Save data applied to molecule attributes.

val txReport = Person.name("Ben").age(42).save

// Data has been saved in db
Person.name.age.get === List(("Ben", 42))

A TxReport is returned with info about the result of the save transaction.

The save operation is synchronous and can be wrapped in a Future if asynchronicity is required.

conn: Implicit Conn value in scope
returns: TxReport

Definition Classes: Molecule

final lazy val sdf: SimpleDateFormat

Attributes: protected
Definition Classes: Helpers

final def seq[T](values: Seq[T]): String

Attributes: protected
Definition Classes: Helpers

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

Definition Classes: AnyRef

final def time(n: Int, prev: Int = 0): Unit

Attributes: protected
Definition Classes: Helpers

def toString(): String

Definition Classes: AnyRef → Any

final def tupleToSeq(arg: Any): Seq[Any]

Attributes: protected
Definition Classes: Helpers

def update(implicit conn: Conn): TxReport

Update entity with data applied to molecule attributes.

// Current data
val ben = Person.name("Ben").age(42).save.eid

// Update entity of of Ben with new age value
Person(ben).age(43).update

// Ben is now 43
Person.name.age.get === List(("ben", 43))

A TxReport is returned with info about the result of the update transaction.

The update operation is synchronous and can be wrapped in a Future if asynchronicity is required.

conn: Implicit Conn value in scope
returns: TxReport

Definition Classes: Molecule

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: @native() @throws( ... )

val xx: Array[Int]

Definition Classes: GetList

object debugInsert extends debugInsert with checkInsertModel

See debugInsert

object getInsertTx extends getInsertTx with checkInsertModel

See getInsertTx

object insert extends insert with checkInsertModel

See insert

object mkDate

Attributes: protected
Definition Classes: Helpers

action		Actions on molecules and entities.
api		Molecule import interfaces of various arities.
ast		Internal Molecule ASTs.
boilerplate		Internal interfaces for auto-generated DSL boilerplate code.
composition		Builder methods to compose molecules.
exceptions		Exceptions thrown by Molecule.
expression		Attribute expressions and operations.
facade		Molecule facades to Datomic.
factory		Implicit macro methods `m` to instantiate molecules from custom DSL molecule constructs.
generic		Interfaces to generic information about datoms and Datomic database.
input		Input molecules awaiting input.
macro		Internal macros generating molecule code from custom DSL molecule constructs.
ops		Internal operational helpers for transforming DSL to molecule.
schema		Schema definition DSL.
transform		Internal transformers from DSL to Model/Query/Transaction.
util		Internal Java database functions for Datomic.

Packages

Sub-packages

Molecule09 

abstract class Molecule09[A, B, C, D, E, F, G, H, I] extends Molecule[(A, B, C, D, E, F, G, H, I)]

Instance Constructors

Type Members

Value Members

Inherited from Molecule[(A, B, C, D, E, F, G, H, I)]

Inherited from ShowDebug[(A, B, C, D, E, F, G, H, I)]

Inherited from GetJson

Inherited from GetRaw

Inherited from GetList[(A, B, C, D, E, F, G, H, I)]

Inherited from GetIterable[(A, B, C, D, E, F, G, H, I)]

Inherited from GetArray[(A, B, C, D, E, F, G, H, I)]

Inherited from JsonBuilder

Inherited from CastHelpers[(A, B, C, D, E, F, G, H, I)]

Inherited from Helpers

Inherited from MoleculeBase

Inherited from AnyRef

Inherited from Any

get

asof

getArrayAsOf

getIterableAsOf

getJsonAsOf

getRawAsOf

getSince

getArraySince

getIterableSince

getJsonSince

getRawSince

getWith

getArrayWith

getIterableWith

getJsonWith

getRawWith

getHistory

save

insert

update

tx

Debug get

Debug action

Internal (but public) model/query representations

Ungrouped

Molecule09