GetList

trait GetList[Tpl] extends GetArray[Tpl]

Default data getter methods on molecules that return List[Tpl].

For expected smaller result sets it's convenient to return Lists of tuples of data. Considered as the default getter, no postfix has been added (get instead of getList).

Self Type: Molecule[Tpl]
Source: GetList.scala

Linear Supertypes

GetArray[Tpl], AnyRef, Any

Known Subclasses

Molecule, Molecule01, Molecule02, Molecule03, Molecule04, Molecule05, Molecule06, Molecule07, Molecule08, Molecule09, Molecule10, Molecule11, Molecule12, Molecule13, Molecule14, Molecule15, Molecule16, Molecule17, Molecule18, Molecule19, Molecule20, Molecule21, Molecule22

Type Hierarchy

Ordering

Grouped
Alphabetic
By Inheritance

Inherited

GetList
GetArray
AnyRef
Any

Hide All
Show All

Visibility

Public
Protected

Value Members

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
final def asInstanceOf[T0]: T0
Definition Classes
Any
def clone(): AnyRef
Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.CloneNotSupportedException]) @native()
final def eq(arg0: AnyRef): Boolean
Definition Classes
AnyRef
def equals(arg0: AnyRef): Boolean
Definition Classes
AnyRef → Any
def finalize(): Unit
Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.Throwable])
def get(n: Int)(implicit conn: Conn): List[Tpl]
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
See also
Equivalent asynchronous getAsync method.
def get(implicit conn: Conn): List[Tpl]
Get List of all rows as tuples matching molecule.
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
See also
Equivalent asynchronous getAsync method.
def getArray(n: Int)(implicit conn: Conn, tplType: ClassTag[Tpl]): Array[Tpl]
Get Array of n rows as tuples matching molecule.
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[Tpl]): Array[Tpl]
Get Array of all rows as tuples matching molecule.
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[Tpl]): Array[Tpl]
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
Manual on asof/since
Equivalent asynchronous getAsyncArrayAsOf method.

def getArrayAsOf(date: Date)(implicit conn: Conn, tplType: ClassTag[Tpl]): Array[Tpl]

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: Manual on asof/since
Equivalent asynchronous getAsyncArrayAsOf method.

def getArrayAsOf(tx: TxReport, n: Int)(implicit conn: Conn, tplType: ClassTag[Tpl]): Array[Tpl]
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
Manual on asof/since
Equivalent asynchronous getAsyncArrayAsOf method.
def getArrayAsOf(tx: TxReport)(implicit conn: Conn, tplType: ClassTag[Tpl]): Array[Tpl]
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
Manual on asof/since
Equivalent asynchronous getAsyncArrayAsOf method.
def getArrayAsOf(t: Long, n: Int)(implicit conn: Conn, tplType: ClassTag[Tpl]): Array[Tpl]
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
Manual on asof/since
Equivalent asynchronous getAsyncArrayAsOf method.
def getArrayAsOf(t: Long)(implicit conn: Conn, tplType: ClassTag[Tpl]): Array[Tpl]
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
Manual on asof/since
Equivalent asynchronous getAsyncArrayAsOf method.
def getArraySince(date: Date, n: Int)(implicit conn: Conn, tplType: ClassTag[Tpl]): Array[Tpl]
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
Manual on asof/since
Equivalent asynchronous getAsyncArraySince method.
def getArraySince(date: Date)(implicit conn: Conn, tplType: ClassTag[Tpl]): Array[Tpl]
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
Manual on asof/since
Equivalent asynchronous getAsyncArraySince method.
def getArraySince(tx: TxReport, n: Int)(implicit conn: Conn, tplType: ClassTag[Tpl]): Array[Tpl]
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
Manual on asof/since
Equivalent asynchronous getAsyncArraySince method.
def getArraySince(tx: TxReport)(implicit conn: Conn, tplType: ClassTag[Tpl]): Array[Tpl]
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
Manual on asof/since
Equivalent asynchronous getAsyncArraySince method.
def getArraySince(t: Long, n: Int)(implicit conn: Conn, tplType: ClassTag[Tpl]): Array[Tpl]
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
Manual on asof/since
Equivalent asynchronous getAsyncArraySince method.
def getArraySince(t: Long)(implicit conn: Conn, tplType: ClassTag[Tpl]): Array[Tpl]
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
Manual on asof/since
Equivalent asynchronous getAsyncArraySince method.
def getArrayWith(txData: List[_], n: Int)(implicit conn: Conn, tplType: ClassTag[Tpl]): Array[Tpl]
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
Manual on with
Equivalent asynchronous getAsyncArrayWith method.
def getArrayWith(txData: List[_])(implicit conn: Conn, tplType: ClassTag[Tpl]): Array[Tpl]
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
Manual on with
Equivalent asynchronous getAsyncArrayWith method.
def getArrayWith(n: Int, txMolecules: Seq[Seq[Statement]]*)(implicit conn: Conn, tplType: ClassTag[Tpl]): Array[Tpl]
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
Manual on with
Equivalent asynchronous getAsyncArrayWith method.
def getArrayWith(txMolecules: Seq[Seq[Statement]]*)(implicit conn: Conn, tplType: ClassTag[Tpl]): Array[Tpl]
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
Manual on with
Equivalent asynchronous getAsyncArrayWith method.

def getAsOf(date: Date, n: Int)(implicit conn: Conn): List[Tpl]

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

See also: Manual on asof/since
Equivalent asynchronous getAsyncAsOf method.

def getAsOf(date: Date)(implicit conn: Conn): List[Tpl]

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

See also: Manual on asof/since
Equivalent asynchronous getAsyncAsOf method.

def getAsOf(tx: TxReport, n: Int)(implicit conn: Conn): List[Tpl]
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
See also
Manual on asof/since
Equivalent asynchronous getAsyncAsOf method.
def getAsOf(tx: TxReport)(implicit conn: Conn): List[Tpl]
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
See also
Manual on asof/since
Equivalent asynchronous getAsyncAsOf method.

def getAsOf(t: Long, n: Int)(implicit conn: Conn): List[Tpl]

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

See also: Manual on asof/since
Equivalent asynchronous getAsyncAsOf method.

def getAsOf(t: Long)(implicit conn: Conn): List[Tpl]

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

See also: Manual on asof/since
Equivalent asynchronous getAsyncAsOf method.

final def getClass(): Class[_ <: AnyRef]
Definition Classes
AnyRef → Any
Annotations
@native()
def getHistory(implicit conn: Conn): List[Tpl]
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
See also
manual for more info on generic attributes.
Equivalent asynchronous getAsyncHistory method.
def getListOf[T](implicit conn: Conn): List[T]

def getSince(date: Date, n: Int)(implicit conn: Conn): List[Tpl]

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

See also: Manual on asof/since
Equivalent asynchronous getAsyncSince method.

def getSince(date: Date)(implicit conn: Conn): List[Tpl]

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

See also: Manual on asof/since
Equivalent asynchronous getAsyncSince method.

def getSince(tx: TxReport, n: Int)(implicit conn: Conn): List[Tpl]
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
See also
Manual on asof/since
Equivalent asynchronous getAsyncSince method.
def getSince(tx: TxReport)(implicit conn: Conn): List[Tpl]
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
See also
Manual on asof/since
Equivalent asynchronous getAsyncSince method.
def getSince(t: Long, n: Int)(implicit conn: Conn): List[Tpl]
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
See also
Manual on asof/since
Equivalent asynchronous getAsyncSince method.
def getSince(t: Long)(implicit conn: Conn): List[Tpl]
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
See also
Manual on asof/since
Equivalent asynchronous getAsyncSince method.
def getWith(txData: List[_], n: Int)(implicit conn: Conn): List[Tpl]
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
See also
Manual on with
Equivalent asynchronous getAsyncWith method.
def getWith(txData: List[_])(implicit conn: Conn): List[Tpl]
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
See also
Manual on with
Equivalent asynchronous getAsyncWith method.
def getWith(n: Int, txMolecules: Seq[Seq[Statement]]*)(implicit conn: Conn): List[Tpl]
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
Note
Note how the n parameter has to come before the txMolecules vararg.
See also
Manual on with
Equivalent asynchronous getAsyncWith method.
def getWith(txMolecules: Seq[Seq[Statement]]*)(implicit conn: Conn): List[Tpl]
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
See also
Manual on with
Equivalent asynchronous getAsyncWith method.
def hashCode(): Int
Definition Classes
AnyRef → Any
Annotations
@native()
final def isInstanceOf[T0]: Boolean
Definition Classes
Any
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 synchronized[T0](arg0: => T0): T0
Definition Classes
AnyRef
def toString(): String
Definition Classes
AnyRef → Any
final def wait(): Unit
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.InterruptedException])
final def wait(arg0: Long, arg1: Int): Unit
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.InterruptedException])
final def wait(arg0: Long): Unit
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.InterruptedException]) @native()

api		Molecule API.
ast		Internal Molecule ASTs.
boilerplate		Internal interfaces for auto-generated DSL boilerplate code.
composition		Builder methods to compose molecules.
exceptions		Exceptions thrown by Molecule.
expression		Attribute expressions and operations.
facade		Molecule facades to Datomic.
factory		Implicit macro methods `m` to instantiate molecules from custom DSL molecule constructs.
input		Input molecules awaiting input.
macros		Internal macros generating molecule code from custom DSL molecule constructs.
generic		Interfaces to generic information about datoms and Datomic database.
ops		Internal operational helpers for transforming DSL to molecule.
schema		Schema definition DSL.
transform		Internal transformers from DSL to Model/Query/Transaction.
util		Internal Java database functions for Datomic.

Packages

Sub-packages

GetList

trait GetList[Tpl] extends GetArray[Tpl]

Value Members

Inherited from GetArray[Tpl]

Inherited from AnyRef

Inherited from Any

get

getArrayAsOf

getArraySince

getArrayWith

getAsOf

getHistory

getSince

getWith

Ungrouped

Packages

Sub-packages

GetList

trait GetList[Tpl] extends GetArray[Tpl]

Value Members

Inherited from GetArray[Tpl]

Inherited from AnyRef

Inherited from Any

get

getArrayAsOf

getArraySince

getArrayWith

getAsOf

getHistory

getSince

getWith

Ungrouped

GetList