Get current adhoc/test/live db.

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

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

Get out of test mode and back to live db.

Adds an asJavaCollection method that implicitly converts a Scala Iterable to an immutable Java Collection.

Adds an asJavaDictionary method that implicitly converts a Scala mutable Map to a Java Dictionary.

Adds an asJavaEnumeration method that implicitly converts a Scala Iterator to a Java Enumeration.

Adds an asJava method that implicitly converts a Scala Iterable to a Java Iterable.

Adds an asJava method that implicitly converts a Scala Iterator to a Java Iterator.

Adds an asScala method that implicitly converts a Java List to a Scala mutable Buffer.

Adds an asScala method that implicitly converts a Java Iterator to a Scala Iterator.

Adds an asScala method that implicitly converts a Java Set to a Scala mutable Set.

Adds an asJava method that implicitly converts a Scala mutable Buffer to a Java List.

Adds an asScala method that implicitly converts a Java Collection to an Scala Iterable.

Adds an asScala method that implicitly converts a Java Dictionary to a Scala mutable Map.

Adds an asScala method that implicitly converts a Java Enumeration to a Scala Iterator.

Adds an asScala method that implicitly converts a Java Iterable to a Scala Iterable.

Adds an asJava method that implicitly converts a Scala mutable concurrent.Map to a Java ConcurrentMap.

Adds an asJava method that implicitly converts a Scala Map to a Java Map.

Adds an asScala method that implicitly converts a Java ConcurrentMap to a Scala mutable concurrent.Map.

Adds an asScala method that implicitly converts a Java Map to a Scala mutable Map.

Adds an asJava method that implicitly converts a Scala mutable Map to a Java Map.

Adds an asJava method that implicitly converts a Scala mutable Seq to a Java List.

Adds an asJava method that implicitly converts a Scala mutable Set to a Java Set.

Adds an asScala method that implicitly converts a Java Properties to a Scala mutable Map[String, 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 ()

Adds an asJava method that implicitly converts a Scala Seq to a Java List.

Adds an asJava method that implicitly converts a Scala Set to a Java Set.

Use test database as of date.

Use test database as of transaction report.

Use test database as of time t / tx id.

Transact java statements

Only works on jvm platform.

Transact statements from a java.util.Reader

Only works on jvm platform.

Transact EDN data string