Molecule 0.23.2 - molecule.core.api.Molecule.Molecule11

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 _getInsertTx(conn: Conn, dataRows: Iterable[Seq[Any]]): Seq[Seq[Statement]]

Attributes: protected
Definition Classes: Molecule

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

Attributes: protected
Definition Classes: Molecule

def _insertAsync(conn: Conn, model: Model, dataRows: Iterable[Seq[Any]])(implicit ec: ExecutionContext): Future[TxReport]

Attributes: protected
Definition Classes: Molecule

def _inspectInsert(conn: Conn, dataRows: Iterable[Seq[Any]]): Unit

Attributes: protected
Definition Classes: ShowInspect

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: Molecule11 → 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: Molecule11 → 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: Molecule11 → MoleculeBase

val _rawNestedQuery: Option[Query]

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

Internal un-optimized 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: Molecule11 → MoleculeBase

val _rawQuery: Query

Internal un-optimized Query representation molecule.

Internal un-optimized Query representation molecule.

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

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

Definition Classes: Molecule11 → MoleculeBase

final def asInstanceOf[T0]: T0

Definition Classes: Any

def cast(value: Any): String

Attributes: protected
Definition Classes: Helpers

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

Attributes: protected
Definition Classes: CastHelpersAggr

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

Attributes: protected
Definition Classes: CastHelpersAggr

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

Attributes: protected
Definition Classes: CastHelpersAggr

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

Attributes: protected
Definition Classes: CastHelpersAggr

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

Attributes: protected
Definition Classes: CastHelpersAggr

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

Attributes: protected
Definition Classes: CastHelpersAggr

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

Attributes: protected
Definition Classes: CastHelpersAggr

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

Attributes: protected
Definition Classes: CastHelpersAggr

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

Attributes: protected
Definition Classes: CastHelpersAggr

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

Attributes: protected
Definition Classes: CastHelpersAggr

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

Attributes: protected
Definition Classes: CastHelpersAggr

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

Attributes: protected
Definition Classes: CastHelpersAggr

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

Attributes: protected
Definition Classes: CastHelpersAggr

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

Attributes: protected
Definition Classes: CastHelpersAggr

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

Attributes: protected
Definition Classes: CastHelpersAggr

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

Attributes: protected
Definition Classes: CastHelpersAggr

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

Attributes: protected
Definition Classes: CastHelpersAggr

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

Attributes: protected
Definition Classes: CastHelpersAggr

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

Attributes: protected
Definition Classes: CastHelpersAggr

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

Attributes: protected
Definition Classes: CastHelpersAggr

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

Attributes: protected
Definition Classes: CastHelpersAggr

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

Attributes: protected
Definition Classes: CastHelpersAggr

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

Attributes: protected
Definition Classes: CastHelpersAggr

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

Attributes: protected
Definition Classes: CastHelpersAggr

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

Attributes: protected
Definition Classes: CastHelpersAggr

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

Attributes: protected
Definition Classes: CastHelpersAggr

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

Attributes: protected
Definition Classes: CastHelpersAggr

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

Attributes: protected
Definition Classes: CastHelpersAggr

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

Attributes: protected
Definition Classes: CastHelpersAggr

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

Attributes: protected
Definition Classes: CastHelpersAggr

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

Attributes: protected
Definition Classes: CastHelpersAggr

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

Attributes: protected
Definition Classes: CastHelpersAggr

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

Attributes: protected
Definition Classes: CastHelpersAggr

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

Attributes: protected
Definition Classes: CastHelpersAggr

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

Attributes: protected
Definition Classes: CastHelpersAggr

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

Attributes: protected
Definition Classes: CastHelpersAggr

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

Attributes: protected
Definition Classes: CastHelpersAggr

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

Attributes: protected
Definition Classes: CastHelpersAggr

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

Attributes: protected
Definition Classes: CastHelpersAggr

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

Attributes: protected
Definition Classes: CastHelpersAggr

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

Attributes: protected
Definition Classes: CastHelpersAggr

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

Attributes: protected
Definition Classes: CastHelpersAggr

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

Attributes: protected
Definition Classes: CastHelpersAggr

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

Attributes: protected
Definition Classes: CastHelpersAggr

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

Attributes: protected
Definition Classes: CastHelpersAggr

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

Attributes: protected
Definition Classes: CastHelpersAggr

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

Attributes: protected
Definition Classes: CastHelpersAggr

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

Attributes: protected
Definition Classes: CastHelpersAggr

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 castManyURI(row: List[_], i: Int): Set[URI]

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 castOneInt2(row: List[_], i: Int): Int

Attributes: protected
Definition Classes: CastHelpers

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

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 castOptManyApplyURI(row: List[_], i: Int): Option[Set[URI]]

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 castOptManyURI(row: List[_], i: Int): Option[Set[URI]]

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 castOptNestedMany[T](it: Iterator[_]): Set[T]

Attributes: protected
Definition Classes: CastHelpersOptNested

def castOptNestedManyBigDecimal(it: Iterator[_]): Set[BigDecimal]

Attributes: protected
Definition Classes: CastHelpersOptNested

def castOptNestedManyBigInt(it: Iterator[_]): Set[BigInt]

Attributes: protected
Definition Classes: CastHelpersOptNested

def castOptNestedManyEnum(it: Iterator[_]): Set[String]

Attributes: protected
Definition Classes: CastHelpersOptNested

def castOptNestedManyFloat(it: Iterator[_]): Set[Float]

Attributes: protected
Definition Classes: CastHelpersOptNested

def castOptNestedManyInt(it: Iterator[_]): Set[Int]

Attributes: protected
Definition Classes: CastHelpersOptNested

def castOptNestedManyRefAttr(it: Iterator[_]): Set[Long]

Attributes: protected
Definition Classes: CastHelpersOptNested

def castOptNestedMapBigDecimal(it: Iterator[_]): Map[String, BigDecimal]

Attributes: protected
Definition Classes: CastHelpersOptNested

def castOptNestedMapBigInt(it: Iterator[_]): Map[String, BigInt]

Attributes: protected
Definition Classes: CastHelpersOptNested

def castOptNestedMapBoolean(it: Iterator[_]): Map[String, Boolean]

Attributes: protected
Definition Classes: CastHelpersOptNested

def castOptNestedMapDate(it: Iterator[_]): Map[String, Date]

Attributes: protected
Definition Classes: CastHelpersOptNested

def castOptNestedMapDouble(it: Iterator[_]): Map[String, Double]

Attributes: protected
Definition Classes: CastHelpersOptNested

def castOptNestedMapFloat(it: Iterator[_]): Map[String, Float]

Attributes: protected
Definition Classes: CastHelpersOptNested

def castOptNestedMapInt(it: Iterator[_]): Map[String, Int]

Attributes: protected
Definition Classes: CastHelpersOptNested

def castOptNestedMapLong(it: Iterator[_]): Map[String, Long]

Attributes: protected
Definition Classes: CastHelpersOptNested

def castOptNestedMapString(it: Iterator[_]): Map[String, String]

Attributes: protected
Definition Classes: CastHelpersOptNested

def castOptNestedMapURI(it: Iterator[_]): Map[String, URI]

Attributes: protected
Definition Classes: CastHelpersOptNested

def castOptNestedMapUUID(it: Iterator[_]): Map[String, UUID]

Attributes: protected
Definition Classes: CastHelpersOptNested

def castOptNestedOne[T](it: Iterator[_]): T

Attributes: protected
Definition Classes: CastHelpersOptNested

def castOptNestedOneBigDecimal(it: Iterator[_]): BigDecimal

Attributes: protected
Definition Classes: CastHelpersOptNested

def castOptNestedOneBigInt(it: Iterator[_]): BigInt

Attributes: protected
Definition Classes: CastHelpersOptNested

def castOptNestedOneEnum(it: Iterator[_]): String

Attributes: protected
Definition Classes: CastHelpersOptNested

def castOptNestedOneFloat(it: Iterator[_]): Float

Attributes: protected
Definition Classes: CastHelpersOptNested

def castOptNestedOneInt(it: Iterator[_]): Int

Attributes: protected
Definition Classes: CastHelpersOptNested

def castOptNestedOneInt2(it: Iterator[_]): Int

Attributes: protected
Definition Classes: CastHelpersOptNested

def castOptNestedOneRefAttr(it: Iterator[_]): Long

Attributes: protected
Definition Classes: CastHelpersOptNested

def castOptNestedOptMany[T](it: Iterator[_]): Option[Set[T]]

Attributes: protected
Definition Classes: CastHelpersOptNested

def castOptNestedOptManyBigDecimal(it: Iterator[_]): Option[Set[BigDecimal]]

Attributes: protected
Definition Classes: CastHelpersOptNested

def castOptNestedOptManyBigInt(it: Iterator[_]): Option[Set[BigInt]]

Attributes: protected
Definition Classes: CastHelpersOptNested

def castOptNestedOptManyDouble(it: Iterator[_]): Option[Set[Double]]

Attributes: protected
Definition Classes: CastHelpersOptNested

def castOptNestedOptManyEnum(it: Iterator[_]): Option[Set[String]]

Attributes: protected
Definition Classes: CastHelpersOptNested

def castOptNestedOptManyFloat(it: Iterator[_]): Option[Set[Float]]

Attributes: protected
Definition Classes: CastHelpersOptNested

def castOptNestedOptManyInt(it: Iterator[_]): Option[Set[Int]]

Attributes: protected
Definition Classes: CastHelpersOptNested

def castOptNestedOptManyLong(it: Iterator[_]): Option[Set[Long]]

Attributes: protected
Definition Classes: CastHelpersOptNested

def castOptNestedOptManyRefAttr(it: Iterator[_]): Option[Set[Long]]

Attributes: protected
Definition Classes: CastHelpersOptNested

def castOptNestedOptMapBigDecimal(it: Iterator[_]): Option[Map[String, BigDecimal]]

Attributes: protected
Definition Classes: CastHelpersOptNested

def castOptNestedOptMapBigInt(it: Iterator[_]): Option[Map[String, BigInt]]

Attributes: protected
Definition Classes: CastHelpersOptNested

def castOptNestedOptMapBoolean(it: Iterator[_]): Option[Map[String, Boolean]]

Attributes: protected
Definition Classes: CastHelpersOptNested

def castOptNestedOptMapDate(it: Iterator[_]): Option[Map[String, Date]]

Attributes: protected
Definition Classes: CastHelpersOptNested

def castOptNestedOptMapDouble(it: Iterator[_]): Option[Map[String, Double]]

Attributes: protected
Definition Classes: CastHelpersOptNested

def castOptNestedOptMapFloat(it: Iterator[_]): Option[Map[String, Float]]

Attributes: protected
Definition Classes: CastHelpersOptNested

def castOptNestedOptMapInt(it: Iterator[_]): Option[Map[String, Int]]

Attributes: protected
Definition Classes: CastHelpersOptNested

def castOptNestedOptMapLong(it: Iterator[_]): Option[Map[String, Long]]

Attributes: protected
Definition Classes: CastHelpersOptNested

def castOptNestedOptMapString(it: Iterator[_]): Option[Map[String, String]]

Attributes: protected
Definition Classes: CastHelpersOptNested

def castOptNestedOptMapURI(it: Iterator[_]): Option[Map[String, URI]]

Attributes: protected
Definition Classes: CastHelpersOptNested

def castOptNestedOptMapUUID(it: Iterator[_]): Option[Map[String, UUID]]

Attributes: protected
Definition Classes: CastHelpersOptNested

def castOptNestedOptOne[T](it: Iterator[_]): Option[T]

Attributes: protected
Definition Classes: CastHelpersOptNested

def castOptNestedOptOneBigDecimal(it: Iterator[_]): Option[BigDecimal]

Attributes: protected
Definition Classes: CastHelpersOptNested

def castOptNestedOptOneBigInt(it: Iterator[_]): Option[BigInt]

Attributes: protected
Definition Classes: CastHelpersOptNested

def castOptNestedOptOneDouble(it: Iterator[_]): Option[Double]

Attributes: protected
Definition Classes: CastHelpersOptNested

def castOptNestedOptOneEnum(it: Iterator[_]): Option[String]

Attributes: protected
Definition Classes: CastHelpersOptNested

def castOptNestedOptOneFloat(it: Iterator[_]): Option[Float]

Attributes: protected
Definition Classes: CastHelpersOptNested

def castOptNestedOptOneInt(it: Iterator[_]): Option[Int]

Attributes: protected
Definition Classes: CastHelpersOptNested

def castOptNestedOptOneLong(it: Iterator[_]): Option[Long]

Attributes: protected
Definition Classes: CastHelpersOptNested

def castOptNestedOptOneRefAttr(it: Iterator[_]): Option[Long]

Attributes: protected
Definition Classes: CastHelpersOptNested

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 castOptOneApplyURI(row: List[_], i: Int): Option[URI]

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 castOptOneURI(row: List[_], i: Int): Option[URI]

Attributes: protected
Definition Classes: CastHelpers

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

Attributes: protected
Definition Classes: CastHelpers

def clean(attr: String): String

Definition Classes: Helpers

def clone(): AnyRef

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

def date2datomicStr(date: Date, zoneOffset: ZoneOffset = localZoneOffset): String

Definition Classes: DateHandling

def date2str(date: Date, zoneOffset: ZoneOffset = localZoneOffset): String

Definition Classes: DateHandling

def daylight(ms: Long): Int

Definition Classes: DateHandling

final def eq(arg0: AnyRef): Boolean

Definition Classes: AnyRef

def equals(arg0: Any): Boolean

Definition Classes: AnyRef → Any

def escStr(s: String): String

Definition Classes: Helpers

def expandDateStr(dateStr: String): String

Definition Classes: DateHandling

final def f(a: Any): Any

Attributes: protected
Definition Classes: Helpers

def finalize(): Unit

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

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

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
See also: Equivalent asynchronous getAsync method.

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

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
See also: Equivalent asynchronous getAsync method.

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

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. Setting n to -1 fetches all rows (same as calling getArray without any number of rows parameter).

n: Number of rows. If -1, all rows are fetched.
conn: Implicit Conn value in scope
tplType: Implicit ClassTag[Tpl] to capture Tuple type for Array
returns: Array[Tpl] where Tpl is a tuple of types matching the attributes of the molecule

Definition Classes: GetArray
See also: Equivalent asynchronous getAsyncArray method.

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

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
tplType: Implicit ClassTag[Tpl] to capture Tuple type for Array
returns: Array[Tpl] where Tpl is a tuple of types matching the attributes of the molecule

Definition Classes: GetArray
See also: Equivalent asynchronous getAsyncArray method.

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

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
tplType: Implicit ClassTag[Tpl] to capture Tuple type for Array
returns: Array[Tpl] where Tpl is a tuple of data matching molecule

Definition Classes: GetArray
See also: Equivalent asynchronous getAsyncArrayAsOf method.

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

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
tplType: Implicit ClassTag[Tpl] to capture Tuple type for Array
returns: Array[Tpl] where Tpl is a tuple of data matching molecule

Definition Classes: GetArray
See also: Equivalent asynchronous getAsyncArrayAsOf method.

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

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
tplType: Implicit ClassTag[Tpl] to capture Tuple type for Array
returns: Array[Tpl] where Tpl is a tuple of data matching molecule

Definition Classes: GetArray
See also: Equivalent asynchronous getAsyncArrayAsOf method.

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

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
tplType: Implicit ClassTag[Tpl] to capture Tuple type for Array
returns: Array[Tpl] where Tpl is a tuple of data matching molecule

Definition Classes: GetArray
See also: Equivalent asynchronous getAsyncArrayAsOf method.

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

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
tplType: Implicit ClassTag[Tpl] to capture Tuple type for Array
returns: Array[Tpl] where Tpl is a tuple of data matching molecule

Definition Classes: GetArray
See also: Equivalent asynchronous getAsyncArrayAsOf method.

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

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
tplType: Implicit ClassTag[Tpl] to capture Tuple type for Array
returns: Array[Tpl] where Tpl is a tuple of data matching molecule

Definition Classes: GetArray
See also: Equivalent asynchronous getAsyncArrayAsOf method.

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

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
tplType: Implicit ClassTag[Tpl] to capture Tuple type for Array
returns: Array[Tpl] where Tpl is a tuple of data matching molecule

Definition Classes: GetArray
See also: Equivalent asynchronous getAsyncArraySince method.

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

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
tplType: Implicit ClassTag[Tpl] to capture Tuple type for Array
returns: Array[Tpl] where Tpl is a tuple of data matching molecule

Definition Classes: GetArray
See also: Equivalent asynchronous getAsyncArraySince method.

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

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 getAsync 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
tplType: Implicit ClassTag[Tpl] to capture Tuple type for Array
returns: Array[Tpl] where Tpl is a tuple of data matching molecule

Definition Classes: GetArray
See also: Equivalent asynchronous getAsyncArraySince method.

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

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 getAsync 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
tplType: Implicit ClassTag[Tpl] to capture Tuple type for Array
returns: Array[Tpl] where Tpl is a tuple of data matching molecule

Definition Classes: GetArray
See also: Equivalent asynchronous getAsyncArraySince method.

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

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
tplType: Implicit ClassTag[Tpl] to capture Tuple type for Array
returns: Array[Tpl] where Tpl is a tuple of data matching molecule

Definition Classes: GetArray
See also: Equivalent asynchronous getAsyncArraySince method.

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

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
tplType: Implicit ClassTag[Tpl] to capture Tuple type for Array
returns: Array[Tpl] where Tpl is a tuple of data matching molecule

Definition Classes: GetArray
See also: Equivalent asynchronous getAsyncArraySince method.

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

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
tplType: Implicit ClassTag[Tpl] to capture Tuple type for Array
returns: Array[Tpl] where Tpl is a tuple of data matching molecule

Definition Classes: GetArray
See also: Equivalent asynchronous getAsyncArrayWith method.

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

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
tplType: Implicit ClassTag[Tpl] to capture Tuple type for Array
returns: Array[Tpl] where Tpl is a tuple of data matching molecule

Definition Classes: GetArray
See also: Equivalent asynchronous getAsyncArrayWith method.

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

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
tplType: Implicit ClassTag[Tpl] to capture Tuple type for Array
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: Equivalent asynchronous getAsyncArrayWith method.

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

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
tplType: Implicit ClassTag[Tpl] to capture Tuple type for Array
returns: Array[Tpl] where Tpl is a tuple of data matching molecule

Definition Classes: GetArray
See also: Equivalent asynchronous getAsyncArrayWith method.

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

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: Equivalent asynchronous getAsyncAsOf method.

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

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: Equivalent asynchronous getAsyncAsOf method.

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

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: Equivalent asynchronous getAsyncAsOf method.

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

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: Equivalent asynchronous getAsyncAsOf method.

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

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: Equivalent asynchronous getAsyncAsOf method.

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

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: Equivalent asynchronous getAsyncAsOf method.

def getAsync(n: Int)(implicit conn: Conn): Future[List[(A, B, C, D, E, F, G, H, I, J, K)]]

Get Future with List of n rows as tuples matching molecule.

Get Future with List of n rows as tuples matching molecule.

For more info and code examples see equivalent synchronous get method.

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: GetAsyncList

def getAsync(implicit conn: Conn): Future[List[(A, B, C, D, E, F, G, H, I, J, K)]]

Get Future with List of all rows as tuples matching molecule.

Get Future with List of all rows as tuples matching molecule.

For more info and code examples see equivalent synchronous get method.

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: GetAsyncList

def getAsyncArray(n: Int)(implicit conn: Conn, tplType: ClassTag[(A, B, C, D, E, F, G, H, I, J, K)]): Future[Array[(A, B, C, D, E, F, G, H, I, J, K)]]

Get Future with Array of n rows as tuples matching molecule.

Get Future with Array of n rows as tuples matching molecule.

For more info and code examples see equivalent synchronous getArray method.

n: Number of rows
conn: Implicit Conn value in scope
tplType: Implicit ClassTag[Tpl] to capture Tuple type for Array
returns: Future[Array[Tpl]] where Tpl is a tuple of types matching the attributes of the molecule

Definition Classes: GetAsyncArray

def getAsyncArray(implicit conn: Conn, tplType: ClassTag[(A, B, C, D, E, F, G, H, I, J, K)]): Future[Array[(A, B, C, D, E, F, G, H, I, J, K)]]

Get Future with Array of all rows as tuples matching molecule.

Get Future with Array of all rows as tuples matching molecule.

For more info and code examples see equivalent synchronous getArray method.

conn: Implicit Conn value in scope
tplType: Implicit ClassTag[Tpl] to capture Tuple type for Array
returns: Future[Array[Tpl]] where Tpl is a tuple of types matching the attributes of the molecule

Definition Classes: GetAsyncArray

def getAsyncArrayAsOf(date: Date, n: Int)(implicit conn: Conn, tplType: ClassTag[(A, B, C, D, E, F, G, H, I, J, K)]): Future[Array[(A, B, C, D, E, F, G, H, I, J, K)]]

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

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

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

For more info and code examples see equivalent synchronous getArrayAsOf method.

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
tplType: Implicit ClassTag[Tpl] to capture Tuple type for Array
returns: Array[Tpl] where Tpl is a tuple of data matching molecule

Definition Classes: GetAsyncArray

def getAsyncArrayAsOf(date: Date)(implicit conn: Conn, tplType: ClassTag[(A, B, C, D, E, F, G, H, I, J, K)]): Future[Array[(A, B, C, D, E, F, G, H, I, J, K)]]

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

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

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

For more info and code examples see equivalent synchronous getArrayAsOf method.

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
tplType: Implicit ClassTag[Tpl] to capture Tuple type for Array
returns: Array[Tpl] where Tpl is a tuple of data matching molecule

Definition Classes: GetAsyncArray

def getAsyncArrayAsOf(tx: TxReport, n: Int)(implicit conn: Conn, tplType: ClassTag[(A, B, C, D, E, F, G, H, I, J, K)]): Future[Array[(A, B, C, D, E, F, G, H, I, J, K)]]

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

Get Future with 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.

For more info and code examples see equivalent synchronous getArrayAsOf method.

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
tplType: Implicit ClassTag[Tpl] to capture Tuple type for Array
returns: Array[Tpl] where Tpl is a tuple of data matching molecule

Definition Classes: GetAsyncArray

def getAsyncArrayAsOf(tx: TxReport)(implicit conn: Conn, tplType: ClassTag[(A, B, C, D, E, F, G, H, I, J, K)]): Future[Array[(A, B, C, D, E, F, G, H, I, J, K)]]

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

Get Future with 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.

For more info and code examples see equivalent synchronous getArrayAsOf method.

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
tplType: Implicit ClassTag[Tpl] to capture Tuple type for Array
returns: Array[Tpl] where Tpl is a tuple of data matching molecule

Definition Classes: GetAsyncArray

def getAsyncArrayAsOf(t: Long, n: Int)(implicit conn: Conn, tplType: ClassTag[(A, B, C, D, E, F, G, H, I, J, K)]): Future[Array[(A, B, C, D, E, F, G, H, I, J, K)]]

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

Get Future with 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).

For more info and code examples see equivalent synchronous getArrayAsOf method.

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
tplType: Implicit ClassTag[Tpl] to capture Tuple type for Array
returns: Array[Tpl] where Tpl is a tuple of data matching molecule

Definition Classes: GetAsyncArray

def getAsyncArrayAsOf(t: Long)(implicit conn: Conn, tplType: ClassTag[(A, B, C, D, E, F, G, H, I, J, K)]): Future[Array[(A, B, C, D, E, F, G, H, I, J, K)]]

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

Get Future with 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).

For more info and code examples see equivalent synchronous getArrayAsOf method.

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
tplType: Implicit ClassTag[Tpl] to capture Tuple type for Array
returns: Array[Tpl] where Tpl is a tuple of data matching molecule

Definition Classes: GetAsyncArray

def getAsyncArraySince(date: Date, n: Int)(implicit conn: Conn, tplType: ClassTag[(A, B, C, D, E, F, G, H, I, J, K)]): Future[Array[(A, B, C, D, E, F, G, H, I, J, K)]]

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

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

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

For more info and code examples see equivalent synchronous getArraySince method.

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
tplType: Implicit ClassTag[Tpl] to capture Tuple type for Array
returns: Array[Tpl] where Tpl is a tuple of data matching molecule

Definition Classes: GetAsyncArray

def getAsyncArraySince(date: Date)(implicit conn: Conn, tplType: ClassTag[(A, B, C, D, E, F, G, H, I, J, K)]): Future[Array[(A, B, C, D, E, F, G, H, I, J, K)]]

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

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

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

For more info and code examples see equivalent synchronous getArraySince method.

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
tplType: Implicit ClassTag[Tpl] to capture Tuple type for Array
returns: Array[Tpl] where Tpl is a tuple of data matching molecule

Definition Classes: GetAsyncArray

def getAsyncArraySince(tx: TxReport, n: Int)(implicit conn: Conn, tplType: ClassTag[(A, B, C, D, E, F, G, H, I, J, K)]): Future[Array[(A, B, C, D, E, F, G, H, I, J, K)]]

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

Get Future with 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.

For more info and code examples see equivalent synchronous getArraySince method.

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
tplType: Implicit ClassTag[Tpl] to capture Tuple type for Array
returns: Array[Tpl] where Tpl is a tuple of data matching molecule

Definition Classes: GetAsyncArray

def getAsyncArraySince(tx: TxReport)(implicit conn: Conn, tplType: ClassTag[(A, B, C, D, E, F, G, H, I, J, K)]): Future[Array[(A, B, C, D, E, F, G, H, I, J, K)]]

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

Get Future with 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.

For more info and code examples see equivalent synchronous getArraySince method.

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
tplType: Implicit ClassTag[Tpl] to capture Tuple type for Array
returns: Array[Tpl] where Tpl is a tuple of data matching molecule

Definition Classes: GetAsyncArray

def getAsyncArraySince(t: Long, n: Int)(implicit conn: Conn, tplType: ClassTag[(A, B, C, D, E, F, G, H, I, J, K)]): Future[Array[(A, B, C, D, E, F, G, H, I, J, K)]]

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

Get Future with 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).

For more info and code examples see equivalent synchronous getArraySince method.

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
tplType: Implicit ClassTag[Tpl] to capture Tuple type for Array
returns: Array[Tpl] where Tpl is a tuple of data matching molecule

Definition Classes: GetAsyncArray

def getAsyncArraySince(t: Long)(implicit conn: Conn, tplType: ClassTag[(A, B, C, D, E, F, G, H, I, J, K)]): Future[Array[(A, B, C, D, E, F, G, H, I, J, K)]]

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

Get Future with 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).

For more info and code examples see equivalent synchronous getArraySince method.

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
tplType: Implicit ClassTag[Tpl] to capture Tuple type for Array
returns: Array[Tpl] where Tpl is a tuple of data matching molecule

Definition Classes: GetAsyncArray

def getAsyncArrayWith(txData: List[_], n: Int)(implicit conn: Conn, tplType: ClassTag[(A, B, C, D, E, F, G, H, I, J, K)]): Future[Array[(A, B, C, D, E, F, G, H, I, J, K)]]

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

Get Future with 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.

For more info and code examples see equivalent synchronous getArrayWith method.

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
tplType: Implicit ClassTag[Tpl] to capture Tuple type for Array
returns: Array[Tpl] where Tpl is a tuple of data matching molecule

Definition Classes: GetAsyncArray

def getAsyncArrayWith(txData: List[_])(implicit conn: Conn, tplType: ClassTag[(A, B, C, D, E, F, G, H, I, J, K)]): Future[Array[(A, B, C, D, E, F, G, H, I, J, K)]]

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

Get Future with 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.

For more info and code examples see equivalent synchronous getArrayWith method.

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
tplType: Implicit ClassTag[Tpl] to capture Tuple type for Array
returns: Array[Tpl] where Tpl is a tuple of data matching molecule

Definition Classes: GetAsyncArray

def getAsyncArrayWith(n: Int, txMolecules: Seq[Seq[Statement]]*)(implicit conn: Conn, tplType: ClassTag[(A, B, C, D, E, F, G, H, I, J, K)]): Future[Array[(A, B, C, D, E, F, G, H, I, J, K)]]

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

Get Future with 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.

For more info and code examples see equivalent synchronous getArrayWith method.

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
tplType: Implicit ClassTag[Tpl] to capture Tuple type for Array
returns: Array[Tpl] where Tpl is a tuple of data matching molecule

Definition Classes: GetAsyncArray
Note: Note how the n parameter has to come before the txMolecules vararg.

def getAsyncArrayWith(txMolecules: Seq[Seq[Statement]]*)(implicit conn: Conn, tplType: ClassTag[(A, B, C, D, E, F, G, H, I, J, K)]): Future[Array[(A, B, C, D, E, F, G, H, I, J, K)]]

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

Get Future with 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.

For more info and code examples see equivalent synchronous getArrayWith method.

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
tplType: Implicit ClassTag[Tpl] to capture Tuple type for Array
returns: Array[Tpl] where Tpl is a tuple of data matching molecule

Definition Classes: GetAsyncArray

def getAsyncAsOf(date: Date, n: Int)(implicit conn: Conn): Future[List[(A, B, C, D, E, F, G, H, I, J, K)]]

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

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

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

For more info and code examples see equivalent synchronous getAsOf method.

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: GetAsyncList

def getAsyncAsOf(date: Date)(implicit conn: Conn): Future[List[(A, B, C, D, E, F, G, H, I, J, K)]]

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

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

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

For more info and code examples see equivalent synchronous getAsOf method.

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

Definition Classes: GetAsyncList

def getAsyncAsOf(tx: TxReport, n: Int)(implicit conn: Conn): Future[List[(A, B, C, D, E, F, G, H, I, J, K)]]

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

Get Future with 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.

For more info and code examples see equivalent synchronous getAsOf method.

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: GetAsyncList

def getAsyncAsOf(tx: TxReport)(implicit conn: Conn): Future[List[(A, B, C, D, E, F, G, H, I, J, K)]]

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

Get Future with 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.

For more info and code examples see equivalent synchronous getAsOf method.

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: GetAsyncList

def getAsyncAsOf(t: Long, n: Int)(implicit conn: Conn): Future[List[(A, B, C, D, E, F, G, H, I, J, K)]]

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

Get Future with 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).

For more info and code examples see equivalent synchronous getAsOf method.

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: GetAsyncList

def getAsyncAsOf(t: Long)(implicit conn: Conn): Future[List[(A, B, C, D, E, F, G, H, I, J, K)]]

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

Get Future with 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).

For more info and code examples see equivalent synchronous getAsOf method.

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

Definition Classes: GetAsyncList

def getAsyncHistory(implicit conn: Conn): Future[List[(A, B, C, D, E, F, G, H, I, J, K)]]

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

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

For more info and code examples see equivalent synchronous getHistory method.

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

Definition Classes: GetAsyncList

def getAsyncIterable(implicit conn: Conn): Future[Iterable[(A, B, C, D, E, F, G, H, I, J, K)]]

Get Future with Iterable of all rows as tuples matching the molecule.

Get Future with Iterable of all rows as tuples matching the molecule.

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

For more info and code examples see equivalent synchronous getIterable method.

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

Definition Classes: GetAsyncIterable

def getAsyncIterableAsOf(date: Date)(implicit conn: Conn): Future[Iterable[(A, B, C, D, E, F, G, H, I, J, K)]]

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

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

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

For more info and code examples see equivalent synchronous getIterableAsOf method.

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

Definition Classes: GetAsyncIterable

def getAsyncIterableAsOf(tx: TxReport)(implicit conn: Conn): Future[Iterable[(A, B, C, D, E, F, G, H, I, J, K)]]

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

Get Future with 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.

For more info and code examples see equivalent synchronous getIterableAsOf method.

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: GetAsyncIterable

def getAsyncIterableAsOf(t: Long)(implicit conn: Conn): Future[Iterable[(A, B, C, D, E, F, G, H, I, J, K)]]

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

Get Future with 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.

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).

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

For more info and code examples see equivalent synchronous getIterableAsOf method.

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

Definition Classes: GetAsyncIterable

def getAsyncIterableSince(date: Date)(implicit conn: Conn): Future[Iterable[(A, B, C, D, E, F, G, H, I, J, K)]]

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

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

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

For more info and code examples see equivalent synchronous getIterableSince method.

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

Definition Classes: GetAsyncIterable

def getAsyncIterableSince(tx: TxReport)(implicit conn: Conn): Future[Iterable[(A, B, C, D, E, F, G, H, I, J, K)]]

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

Get Future with 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.

For more info and code examples see equivalent synchronous getIterableSince method.

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

Definition Classes: GetAsyncIterable

def getAsyncIterableSince(t: Long)(implicit conn: Conn): Future[Iterable[(A, B, C, D, E, F, G, H, I, J, K)]]

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

Get Future with 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.

For more info and code examples see equivalent synchronous getIterableSince method.

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

Definition Classes: GetAsyncIterable

def getAsyncIterableWith(txData: List[_])(implicit conn: Conn): Future[Iterable[(A, B, C, D, E, F, G, H, I, J, K)]]

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

Get Future with 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. *

* For more info and code examples see equivalent synchronous * getIterableWith method.

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

Definition Classes: GetAsyncIterable

def getAsyncIterableWith(txMolecules: Seq[Seq[Statement]]*)(implicit conn: Conn): Future[Iterable[(A, B, C, D, E, F, G, H, I, J, K)]]

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

Get Future with 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.

For more info and code examples see equivalent synchronous getIterableWith method.

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: GetAsyncIterable

def getAsyncJson(n: Int)(implicit conn: Conn): Future[String]

Get Future with json data for n rows matching molecule.

Get Future with json data for n rows matching molecule.

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

For more info and code examples see equivalent synchronous getJson method.

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

Definition Classes: GetAsyncJson

def getAsyncJson(implicit conn: Conn): Future[String]

Get Future with json data for all rows matching molecule.

Get Future with json data for all rows matching molecule.

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

For more info and code examples see equivalent synchronous getJson method.

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

Definition Classes: GetAsyncJson

def getAsyncJsonAsOf(date: Date, n: Int)(implicit conn: Conn): Future[String]

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

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

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

For more info and code examples see equivalent synchronous getJsonAsOf method.

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

Definition Classes: GetAsyncJson

def getAsyncJsonAsOf(date: Date)(implicit conn: Conn): Future[String]

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

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

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

For more info and code examples see equivalent synchronous getJsonAsOf method.

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

Definition Classes: GetAsyncJson

def getAsyncJsonAsOf(tx: TxReport, n: Int)(implicit conn: Conn): Future[String]

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

Get Future with 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.

For more info and code examples see equivalent synchronous getJsonAsOf method.

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: GetAsyncJson

def getAsyncJsonAsOf(tx: TxReport)(implicit conn: Conn): Future[String]

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

Get Future with 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.

For more info and code examples see equivalent synchronous getJsonAsOf method.

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

Definition Classes: GetAsyncJson

def getAsyncJsonAsOf(t: Long, n: Int)(implicit conn: Conn): Future[String]

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

Get Future with 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).

For more info and code examples see equivalent synchronous getJsonAsOf method.

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

Definition Classes: GetAsyncJson

def getAsyncJsonAsOf(t: Long)(implicit conn: Conn): Future[String]

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

Get Future with 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).

For more info and code examples see equivalent synchronous getJsonAsOf method.

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

Definition Classes: GetAsyncJson

def getAsyncJsonSince(date: Date, n: Int)(implicit conn: Conn): Future[String]

Get Future with json data for n rows matching molecule since date.

Get Future with json data for n rows matching molecule since date.

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

For more info and code examples see equivalent synchronous getJsonSince method.

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

Definition Classes: GetAsyncJson

def getAsyncJsonSince(date: Date)(implicit conn: Conn): Future[String]

Get Future with json data for all rows matching molecule since date.

Get Future with json data for all rows matching molecule since date.

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

For more info and code examples see equivalent synchronous getJsonSince method.

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

Definition Classes: GetAsyncJson

def getAsyncJsonSince(tx: TxReport, n: Int)(implicit conn: Conn): Future[String]

Get Future with json data for n rows matching molecule since tx.

Get Future with 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.

For more info and code examples see equivalent synchronous getJsonSince method.

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: GetAsyncJson

def getAsyncJsonSince(tx: TxReport)(implicit conn: Conn): Future[String]

Get Future with json data for all rows matching molecule since tx.

Get Future with 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.

For more info and code examples see equivalent synchronous getJsonSince method.

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

Definition Classes: GetAsyncJson

def getAsyncJsonSince(t: Long, n: Int)(implicit conn: Conn): Future[String]

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

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

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

For more info and code examples see equivalent synchronous getJsonSince method.

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

Definition Classes: GetAsyncJson

def getAsyncJsonSince(t: Long)(implicit conn: Conn): Future[String]

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

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

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

For more info and code examples see equivalent synchronous getJsonSince method.

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

Definition Classes: GetAsyncJson

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

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

Get Future with 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.

For more info and code examples see equivalent synchronous getJsonWith method.

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

Definition Classes: GetAsyncJson

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

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

Get Future with 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.

For more info and code examples see equivalent synchronous getJsonWith method.

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

Definition Classes: GetAsyncJson

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

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

Get Future with 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.

For more info and code examples see equivalent synchronous getJsonWith method.

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: GetAsyncJson

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

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

Get Future with 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.

For more info and code examples see equivalent synchronous getJsonWith method.

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: GetAsyncJson

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

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

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

For more info and code examples see equivalent synchronous getRaw method.

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

Definition Classes: GetAsyncRaw

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

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

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

For more info and code examples see equivalent synchronous getRaw method.

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

Definition Classes: GetAsyncRaw

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

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

Get Future with 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).

For more info and code examples see equivalent synchronous getRawAsOf method.

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: GetAsyncRaw

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

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

Get Future with 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).

For more info and code examples see equivalent synchronous getRawAsOf method.

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

Definition Classes: GetAsyncRaw

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

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

Get Future with java.util.Collection of n 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.

For more info and code examples see equivalent synchronous getRawAsOf method.

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: GetAsyncRaw

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

Get Future with 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.

For more info and code examples see equivalent synchronous getRawAsOf method.

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

Definition Classes: GetAsyncRaw

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

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

Get Future with 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).

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).

For more info and code examples see equivalent synchronous getRawAsOf method.

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: GetAsyncRaw

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

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

Get Future with 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).

For more info and code examples see equivalent synchronous getRawAsOf method.

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

Definition Classes: GetAsyncRaw

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

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

Get Future with 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).

For more info and code examples see equivalent synchronous getRawSince method.

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: GetAsyncRaw

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

Get Future with java.util.Collection of all untyped rows matching molecule since date.

Get Future with 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).

For more info and code examples see equivalent synchronous getRawSince method.

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

Definition Classes: GetAsyncRaw

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

Get Future with java.util.Collection of n untyped rows matching molecule since tx.

Get Future with 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.

For more info and code examples see equivalent synchronous getRawSince method.

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: GetAsyncRaw

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

Get Future with java.util.Collection of all untyped rows matching molecule since tx.

Get Future with 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.

For more info and code examples see equivalent synchronous getRawSince method.

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

Definition Classes: GetAsyncRaw

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

Get Future with java.util.Collection of n untyped rows matching molecule since transaction time t.

Get Future with 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).

For more info and code examples see equivalent synchronous getRawSince method.

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: GetAsyncRaw

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

Get Future with java.util.Collection of all untyped rows matching molecule since transaction time t.

Get Future with 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).

For more info and code examples see equivalent synchronous getRawSince method.

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

Definition Classes: GetAsyncRaw

def getAsyncRawWith(txData: List[_], n: Int)(implicit conn: Conn): Future[Collection[List[AnyRef]]]

Get Future with java.util.Collection of n untyped rows matching molecule with applied raw transaction data.

Get Future with 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.

For more info and code examples see equivalent synchronous getRawWith method.

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: GetAsyncRaw

def getAsyncRawWith(txData: List[_])(implicit conn: Conn): Future[Collection[List[AnyRef]]]

Get Future with java.util.Collection of all untyped rows matching molecule with applied raw transaction data.

Get Future with 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.

For more info and code examples see equivalent synchronous getRawWith method.

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: GetAsyncRaw

def getAsyncRawWith(n: Int, txMolecules: Seq[Seq[Statement]]*)(implicit conn: Conn): Future[Collection[List[AnyRef]]]

Get Future with java.util.Collection of n untyped rows matching molecule with applied molecule transaction data.

Get Future with 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.

For more info and code examples see equivalent synchronous getRawWith method.

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: GetAsyncRaw
Note: Note how the n parameter has to come before the txMolecules vararg.

def getAsyncRawWith(txMolecules: Seq[Seq[Statement]]*)(implicit conn: Conn): Future[Collection[List[AnyRef]]]

Get Future with java.util.Collection of all untyped rows matching molecule with applied molecule transaction data.

Get Future with 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.

For more info and code examples see equivalent synchronous getRawWith method.

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: GetAsyncRaw

def getAsyncSince(date: Date, n: Int)(implicit conn: Conn): Future[List[(A, B, C, D, E, F, G, H, I, J, K)]]

Get Future with List of n rows as tuples matching molecule since date.

Get Future with List of n rows as tuples matching molecule since date.

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

For more info and code examples see equivalent synchronous getSince method.

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: GetAsyncList

def getAsyncSince(date: Date)(implicit conn: Conn): Future[List[(A, B, C, D, E, F, G, H, I, J, K)]]

Get Future with List of all rows as tuples matching molecule since date.

Get Future with List of all rows as tuples matching molecule since date.

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

For more info and code examples see equivalent synchronous getSince method.

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

Definition Classes: GetAsyncList

def getAsyncSince(tx: TxReport, n: Int)(implicit conn: Conn): Future[List[(A, B, C, D, E, F, G, H, I, J, K)]]

Get Future with List of n rows as tuples matching molecule since tx.

Get Future with 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.

For more info and code examples see equivalent synchronous getSince method.

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: GetAsyncList

def getAsyncSince(tx: TxReport)(implicit conn: Conn): Future[List[(A, B, C, D, E, F, G, H, I, J, K)]]

Get Future with List of all rows as tuples matching molecule since tx.

Get Future with 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.

For more info and code examples see equivalent synchronous getSince method.

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

Definition Classes: GetAsyncList

def getAsyncSince(t: Long, n: Int)(implicit conn: Conn): Future[List[(A, B, C, D, E, F, G, H, I, J, K)]]

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

Get Future with 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.

For more info and code examples see equivalent synchronous getSince method.

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: GetAsyncList

def getAsyncSince(t: Long)(implicit conn: Conn): Future[List[(A, B, C, D, E, F, G, H, I, J, K)]]

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

Get Future with 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.

For more info and code examples see equivalent synchronous getSince method.

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

Definition Classes: GetAsyncList

def getAsyncWith(txData: List[_], n: Int)(implicit conn: Conn): Future[List[(A, B, C, D, E, F, G, H, I, J, K)]]

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

Get Future with 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.

For more info and code examples see equivalent synchronous getWith method.

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: GetAsyncList

def getAsyncWith(txData: List[_])(implicit conn: Conn): Future[List[(A, B, C, D, E, F, G, H, I, J, K)]]

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

Get Future with 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.

For more info and code examples see equivalent synchronous getWith method.

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: GetAsyncList

def getAsyncWith(n: Int, txMolecules: Seq[Seq[Statement]]*)(implicit conn: Conn): Future[List[(A, B, C, D, E, F, G, H, I, J, K)]]

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

Get Future with 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.

For more info and code examples see equivalent synchronous getWith method.

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: GetAsyncList
Note: Note how the n parameter has to come before the txMolecules vararg.

def getAsyncWith(txMolecules: Seq[Seq[Statement]]*)(implicit conn: Conn): Future[List[(A, B, C, D, E, F, G, H, I, J, K)]]

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

Get Future with 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.

For more info and code examples see equivalent synchronous getWith method. 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: GetAsyncList

final def getClass(): Class[_]

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

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

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: Equivalent asynchronous getAsyncHistory method.

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

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
See also: Equivalent asynchronous getAsyncIterable method.

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

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: Equivalent asynchronous getAsyncIterableAsOf method.

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

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 getAsync 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: Equivalent asynchronous getAsyncIterableAsOf method.

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

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: Equivalent asynchronous getAsyncIterableAsOf method.

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

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: Equivalent asynchronous getAsyncIterableSince method.

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

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 getAsync 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: Equivalent asynchronous getAsyncIterableSince method.

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

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: Equivalent asynchronous getAsyncIterableSince method.

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

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: Equivalent asynchronous getAsyncIterableWith method.

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

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: Equivalent asynchronous getAsyncIterableWith method.

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: Equivalent asynchronous getAsyncJson method.

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: Equivalent asynchronous getAsyncJson method.

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: Equivalent asynchronous getAsyncJsonAsOf method.

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: Equivalent asynchronous getAsyncJsonAsOf method.

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: Equivalent asynchronous getAsyncJsonAsOf method.

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: Equivalent asynchronous getAsyncJsonAsOf method.

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: Equivalent asynchronous getAsyncJsonAsOf method.

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: Equivalent asynchronous getAsyncJsonAsOf method.

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: Equivalent asynchronous getAsyncJsonSince method.

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: Equivalent asynchronous getAsyncJsonSince method.

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 getAsync 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: Equivalent asynchronous getAsyncJsonSince method.

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 getAsync 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: Equivalent asynchronous getAsyncJsonSince method.

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: Equivalent asynchronous getAsyncJsonSince method.

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: Equivalent asynchronous getAsyncJsonSince method.

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: String of json

Definition Classes: GetJson
See also: Equivalent asynchronous getAsyncJsonWith method.

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: String of json

Definition Classes: GetJson
See also: Equivalent asynchronous getAsyncJsonWith method.

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: Equivalent asynchronous getAsyncJsonWith method.

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: Equivalent asynchronous getAsyncJsonWith method.

def getQuoted(implicit conn: Conn): String

Get quoted output

Makes it easy to copy test results into tests for instance.

Definition Classes: GetList

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
See also: Equivalent asynchronous getAsyncRaw method.

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]]"""

Peer returns java.util.HashSet Client returns clojure.lang.PersistentVector We unify the type by copying to an ArrayList

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

Definition Classes: GetRaw
See also: Equivalent asynchronous getAsyncRaw method.

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: Equivalent asynchronous getAsyncRawAsOf method.

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: Equivalent asynchronous getAsyncRawAsOf method.

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 getAsync 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: Equivalent asynchronous getAsyncRawAsOf method.

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 getAsync 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: Equivalent asynchronous getAsyncRawAsOf method.

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: Equivalent asynchronous getAsyncRawAsOf method.

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: Equivalent asynchronous getAsyncRawAsOf method.

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: Equivalent asynchronous getAsyncRawSince method.

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: Equivalent asynchronous getAsyncRawSince method.

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 getAsync 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: Equivalent asynchronous getAsyncRawSince method.

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 getAsync 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: Equivalent asynchronous getAsyncRawSince method.

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: Equivalent asynchronous getAsyncRawSince method.

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: Equivalent asynchronous getAsyncRawSince method.

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: Equivalent asynchronous getAsyncRawWith method.

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: Equivalent asynchronous getAsyncRawWith method.

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: Equivalent asynchronous getAsyncRawWith method.

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: Equivalent asynchronous getAsyncRawWith method.

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): List[(A, B, C, D, E, F, G, H, I, J, K)]

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: Equivalent asynchronous getAsyncSince method.

def getSince(date: Date)(implicit conn: Conn): List[(A, B, C, D, E, F, G, H, I, J, K)]

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: Equivalent asynchronous getAsyncSince method.

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

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 getAsync 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: Equivalent asynchronous getAsyncSince method.

def getSince(tx: TxReport)(implicit conn: Conn): List[(A, B, C, D, E, F, G, H, I, J, K)]

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 getAsync 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: Equivalent asynchronous getAsyncSince method.

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

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: Equivalent asynchronous getAsyncSince method.

def getSince(t: Long)(implicit conn: Conn): List[(A, B, C, D, E, F, G, H, I, J, K)]

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: Equivalent asynchronous getAsyncSince method.

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): List[(A, B, C, D, E, F, G, H, I, J, K)]

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: Equivalent asynchronous getAsyncWith method.

def getWith(txData: List[_])(implicit conn: Conn): List[(A, B, C, D, E, F, G, H, I, J, K)]

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: Equivalent asynchronous getAsyncWith method.

def getWith(n: Int, txMolecules: Seq[Seq[Statement]]*)(implicit conn: Conn): List[(A, B, C, D, E, F, G, H, I, J, K)]

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: Equivalent asynchronous getAsyncWith method.

def getWith(txMolecules: Seq[Seq[Statement]]*)(implicit conn: Conn): List[(A, B, C, D, E, F, G, H, I, J, K)]

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: Equivalent asynchronous getAsyncWith method.

def hashCode(): Int

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

def inspectGet(implicit conn: Conn): Unit

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

Inspect 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). OBS: printing raw Date's (Clojure Instant) will miss the time-zone

conn: Implicit Conn value in scope

Definition Classes: ShowInspect

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

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

Inspect 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 scsope

Definition Classes: ShowInspect

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

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

Inspect 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: ShowInspect

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

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

Inspect 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: ShowInspect

def inspectGetHistory(implicit conn: Conn): Unit

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

Inspect 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: ShowInspect

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

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

Inspect 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: ShowInspect

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

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

Inspect 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: ShowInspect

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

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

Inspect 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: ShowInspect

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

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

Inspect 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: ShowInspect

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

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

Inspect 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: ShowInspect

def inspectSave(implicit conn: Conn): Unit

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

Inspect 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: ShowInspect

def inspectUpdate(implicit conn: Conn): Unit

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

Inspect 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: ShowInspect

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 jsonAggrList(sb: StringBuilder, field: String, row: List[_], i: Int): StringBuilder

Attributes: protected
Definition Classes: JsonBuilder

def jsonAggrListDate(sb: StringBuilder, field: String, row: List[_], i: Int): StringBuilder

Attributes: protected
Definition Classes: JsonBuilder

def jsonAggrListQuoted(sb: StringBuilder, field: String, row: List[_], i: Int): StringBuilder

Attributes: protected
Definition Classes: JsonBuilder

def jsonAggrListRand(sb: StringBuilder, field: String, row: List[_], i: Int): StringBuilder

Attributes: protected
Definition Classes: JsonBuilder

def jsonAggrListRandDate(sb: StringBuilder, field: String, row: List[_], i: Int): StringBuilder

Attributes: protected
Definition Classes: JsonBuilder

def jsonAggrListRandQuoted(sb: StringBuilder, field: String, row: List[_], i: Int): StringBuilder

Attributes: protected
Definition Classes: JsonBuilder

def jsonAggrListRandToString(sb: StringBuilder, field: String, row: List[_], i: Int): StringBuilder

Attributes: protected
Definition Classes: JsonBuilder

def jsonAggrListToString(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 jsonAggrSingleSample(sb: StringBuilder, field: String, row: List[_], i: Int): StringBuilder

Attributes: protected
Definition Classes: JsonBuilder

def jsonAggrSingleSampleDate(sb: StringBuilder, field: String, row: List[_], i: Int): StringBuilder

Attributes: protected
Definition Classes: JsonBuilder

def jsonAggrSingleSampleQuoted(sb: StringBuilder, field: String, row: List[_], i: Int): StringBuilder

Attributes: protected
Definition Classes: JsonBuilder

def jsonAggrSingleSampleToString(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 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

lazy val localOffset: String

Definition Classes: DateHandling

lazy val localZoneOffset: ZoneOffset

Definition Classes: DateHandling

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

final def os(opt: Option[Set[_]]): String

Attributes: protected
Definition Classes: Helpers

def pair(sb: StringBuilder, field: String, value: Any): StringBuilder

Attributes: protected
Definition Classes: JsonBuilder

def quote(value: Any): String

Attributes: protected
Definition Classes: Quoted

def quote(sb: StringBuilder, s: String): StringBuilder

Attributes: protected
Definition Classes: JsonBuilder

def quote2(value: Any): String

Attributes: protected
Definition Classes: Quoted

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.

Save data applied to molecule attributes.

Returns TxReport having info about the result of the save transaction.

val txReport = Person.name("Ben").age(42).save

// Data has been saved in db
Person.name.age.get === List(("Ben", 42))

The save operation is synchronous and blocking. Use saveAsync for non-blocking asynchronous saves.

conn: Implicit Conn value in scope
returns: TxReport with info about the result of the save transaction.

Definition Classes: Molecule

def saveAsync(implicit conn: Conn, ec: ExecutionContext): Future[TxReport]

Asynchronously save data applied to molecule attributes.

Asynchronously save data applied to molecule attributes.

Returns Future with TxReport having info about the result of the save transaction.

val futureSave: Future[TxReport] = Person.name("Ben").age(42).saveAsync

for {
  _ <- futureSave
  result <- Person.name.age.getAsync
} yield {
  // Data was saved
  result.head === ("Ben", 42)
}

The save operation is asynchronous and non-blocking. Internally calls Datomic's asynchronous API.

conn: Implicit Conn value in scope
returns: TxReport with info about the result of the save transaction.

Definition Classes: Molecule

final def seq[T](values: Seq[T]): String

Attributes: protected
Definition Classes: Helpers

def str2date(s: String, zoneOffset: ZoneOffset = localZoneOffset): Date

Definition Classes: DateHandling

def str2zdt(s: String, zoneOffset: ZoneOffset = localZoneOffset): ZonedDateTime

Definition Classes: DateHandling

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

def truncateDateStr(dateStr: String): String

Definition Classes: DateHandling

final def tupleToSeq(arg: Any): Seq[Any]

Attributes: protected
Definition Classes: Helpers

def unescStr(s: String): String

Definition Classes: Helpers

def untupled(rawData: Iterable[Seq[Any]]): Seq[Seq[Any]]

Attributes: protected
Definition Classes: Molecule

def update(implicit conn: Conn): TxReport

Update entity with data applied to molecule attributes.

Update entity with data applied to molecule attributes.

Returns TxReport with info about the result of the update transaction.

// 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))

The update operation is synchronous and blocking. Use updateAsync for non-blocking asynchronous updates.

conn: Implicit Conn value in scope
returns: TxReport

Definition Classes: Molecule

def updateAsync(implicit conn: Conn, ec: ExecutionContext): Future[TxReport]

Asynchronously update entity with data applied to molecule attributes.

Asynchronously update entity with data applied to molecule attributes. Returns Future with TxReport having info about the result of the update transaction.

for {
  saveTx <- Person.name("Ben").age(42).saveAsync
  benId = saveTx.eid
  updateTx <- Person(benId).age(43).updateAsync
  result <- Person.name.age.getAsync
} yield {
  // Ben is now 43
  result.head === ("ben", 43)
}

The update operation is asynchronous and non-blocking. Internally calls Datomic's asynchronous API.

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: @throws( ... ) @native()

lazy val zone: ZoneId

Definition Classes: DateHandling

object getInsertTx extends getInsertTx with checkInsertModel

See getInsertTx

object insert extends insert with checkInsertModel

See insert

object insertAsync extends insertAsync with checkInsertModel

See insertAsync

object inspectInsert extends inspectInsert with checkInsertModel

See inspectInsert

object mkDate

Attributes: protected
Definition Classes: Helpers

Packages

Molecule11 

abstract class Molecule11[A, B, C, D, E, F, G, H, I, J, K] extends Molecule[(A, B, C, D, E, F, G, H, I, J, K)]

Instance Constructors

Type Members

Value Members

Inherited from Molecule[(A, B, C, D, E, F, G, H, I, J, K)]

Inherited from ShowInspect[(A, B, C, D, E, F, G, H, I, J, K)]

Inherited from GetAsyncJson

Inherited from GetAsyncRaw

Inherited from GetAsyncList[(A, B, C, D, E, F, G, H, I, J, K)]

Inherited from GetAsyncIterable[(A, B, C, D, E, F, G, H, I, J, K)]

Inherited from GetAsyncArray[(A, B, C, D, E, F, G, H, I, J, K)]

Inherited from GetJson

Inherited from GetRaw

Inherited from GetList[(A, B, C, D, E, F, G, H, I, J, K)]

Inherited from Quoted

Inherited from GetIterable[(A, B, C, D, E, F, G, H, I, J, K)]

Inherited from GetArray[(A, B, C, D, E, F, G, H, I, J, K)]

Inherited from JsonBuilder

Inherited from CastHelpers[(A, B, C, D, E, F, G, H, I, J, K)]

Inherited from CastHelpersAggr

Inherited from CastHelpersOptNested

Inherited from Helpers

Inherited from DateHandling

Inherited from RegexMatching

Inherited from MoleculeBase

Inherited from AnyRef

Inherited from Any

get

getAsync

getAsOf

getAsyncAsOf

getArrayAsOf

getAsyncArrayAsOf

getIterableAsOf

getAsyncIterableAsOf

getJsonAsOf

getAsyncJsonAsOf

getRawAsOf

getAsyncRawAsOf

getSince

getAsyncSince

getArraySince

getAsyncArraySince

getIterableSince

getAsyncIterableSince

getJsonSince

getAsyncJsonSince

getRawSince

getAsyncRawSince

getWith

getAsyncWith

getArrayWith

getAsyncArrayWith

getIterableWith

getAsyncIterableWith

getJsonWith

getAsyncJsonWith

getRawWith

getAsyncRawWith

getHistory

save

insert

update

getTx

Inspect get

Inspect operation

Internal (but public) model/query representations

Ungrouped

Molecule11