Synchronize database to have all transactions completed up to and including time t.

Sets a flag with a time t on the connection to do the synchronization on the first subsequent query. Hereafter the flag is removed.

The synchronization guarantees to include all transactions that are complete up to and including time t. sync does not communicate with the transactor, but it can block (within the Future) if the peer/client has not yet been notified of transactions up to time t.

A Future with the synchronized database is returned for the query to use. The future can take arbitrarily long to complete. Waiting code should specify a timeout.

Only use sync(t) when coordination of multiple peer/client processes is required.

If peers/clients do not share a basis t, prefer sync.

Synchronize database to have all transactions completed up until now.

Sets a flag on the connection to do the synchronization on the first subsequent query. Hereafter the flag is removed.

The synchronization guarantees to include all transactions that are complete when the synchronization query is made. Before the query is executed, the connection communicates with the transactor to do the synchronization.

A Future with the synchronized database is returned for the query to use. The future can take arbitrarily long to complete. Waiting code should specify a timeout.

Only use sync when the following two conditions hold:

1. coordination of multiple peer/client processes is required 2. peers/clients have no way to agree on a basis t for coordination

Use test database as of transaction report.

Use test database as of date.

Use test database as of time t / tx id.

Use test database since transaction report.

Use test database since date.

Use test database since time t.

Use test database with temporary transaction statements.

Transaction statements can be supplied from a molecule:

for {
  conn <- futConn // implicit Future[Conn] instance in scope

  // Live data
  benId = Person.name("Ben").save.map(_.eid)

  // Use temporary db with statements of one or more tested transactions
  _ <- conn.testDbWith(
    Person.name("liz").getSaveStmts,
    benId.getRetractStmts
    // more...
  )

  // Query using temporary database
  _ <- Person.name.get.map(_ ==> List("Liz"))

  // Discard test db and go back to live db
  _ = conn.useLiveDb()

  // Query using unchanged live data
  _ <- Person.name.get.map(_ ==> List("Ben"))
} yield ()

Transact EDN data string

Query Datomic directly with Datalog query and optional Scala inputs.

for {
  conn <- futConn // implicit Future[Conn] instance in scope

  // Typed tuple result from molecule
  _ <- Ns.str.int.get.map(_ ==> List(
    ("Liz", 37),
    ("Ben", 42),
  ))

  // Any-type result from query
  _ <- conn.query(
    "[:find  ?b ?c :where [?a :Ns/str ?b][?a :Ns/int ?c]]"
  ).map(_ ==> List(
    List("Liz", 37),
    List("Ben", 42)
  ))

  // Any-type result from query with input(s)
  _ <- conn.query(
    "[:find  ?b ?c :in $ ?c :where [?a :Ns/str ?b][?a :Ns/int ?c]]",
    42
  ).map(_ ==> List(
    List("Ben", 42)
  ))

  // See datalog queries of molecules with `inspectGet`
  _ <- Ns.str.int.inspectGet // shows Datalog query...
} yield ()

Transact java statements

Only works on jvm platform.

Transact statements from a java.util.Reader

Only works on jvm platform.