Molecule 0.23.2 - molecule.datomic.client.facade.Conn

object mkDate

Attributes: protected
Definition Classes: Helpers

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

var _adhocDb: Option[TempDb]

Attributes: protected

def _index(model: Model): Collection[List[AnyRef]]

Definition Classes: Conn_Client → Conn

def _query(model: Model, query: Query, _db: Option[DatomicDb]): Collection[List[AnyRef]]

Definition Classes: Conn_Client → Conn

var _testDb: Option[Db]

Attributes: protected

final def asInstanceOf[T0]: T0

Definition Classes: Any

def cast(value: Any): String

Attributes: protected
Definition Classes: Helpers

def clean(attr: String): String

Definition Classes: Helpers

val client: Client

val clientAsync: AsyncClient

val clientConn: Connection

val clientConnAsync: Future[Either[CognitectAnomaly, AsyncConnection]]

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

def db: DatomicDb

Get current test/live db.

Get current test/live db. Test db has preference.

Definition Classes: Conn_Client → Conn

val dbName: String

def entity(id: Any): DatomicEntity

Convenience method to retrieve entity directly from connection.

Definition Classes: Conn_Client → Conn

final def eq(arg0: AnyRef): Boolean

Definition Classes: AnyRef

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

final def getClass(): Class[_]

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

def getT(tx: Long): Long

Convenience retrieval of time t.

Definition Classes: Conn

final def isInstanceOf[T0]: Boolean

Definition Classes: Any

def liveDbUsed: Boolean

Flag to indicate if live database is used

Definition Classes: Conn_Client → Conn

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 q(db: DatomicDb, query: String, inputs: Seq[Any]): List[List[AnyRef]]

Query Datomic directly with db value and optional Scala inputs.

// Sample data
Ns.str.int.get === List(
  ("Liz", 37),
  ("Ben", 42),
)

// Start out easily with a Datomic query from inspect output
Ns.str.int.inspectGet // shows datomic query...

// Paste Datomic query into `q` call and use some db value
conn.q(conn.db,
       """[:find  ?b ?c
         | :where [?a :Ns/str ?b]
         |        [?a :Ns/int ?c]]""".stripMargin) === List(
  List("Liz", 37),
  List("Ben", 42)
)

// Modify Datomic query to see result, for instance
// by adding input to query and applying input value
conn.q(conn.db,
       """[:find  ?b ?c
         | :in    $ ?c
         | :where [?a :Ns/str ?b]
         |        [?a :Ns/int ?c]]""".stripMargin,
       Seq(42) // input values in list
 ) === List(
  List("Ben", 42)
)

db: Any Datomic Database value (could be asOf(x) etc)
query: Datomic query string
inputs: Seq of optional input(s) to query
returns: List[List[AnyRef]]

Definition Classes: Conn_Datomic → Conn

def q(query: String, inputs: Any*): List[List[AnyRef]]

Query Datomic directly with optional Scala inputs.

// Sample data
Ns.str.int.get === List(
  ("Liz", 37),
  ("Ben", 42),
)

// Start out easily with a Datomic query from inspect output
Ns.str.int.inspectGet // shows datomic query...

// Paste Datomic query into `q` call
conn.q("""[:find  ?b ?c
         | :where [?a :Ns/str ?b]
         |        [?a :Ns/int ?c]]""".stripMargin) === List(
  List("Liz", 37),
  List("Ben", 42)
)

// Modify Datomic query to see result, for instance
// by adding input to query and applying input value
conn.q("""[:find  ?b ?c
         | :in    $ ?c
         | :where [?a :Ns/str ?b]
         |        [?a :Ns/int ?c]]""".stripMargin, 42) === List(
  List("Ben", 42)
)

query: Datomic query string
inputs: Optional input(s) to query
returns: List[List[AnyRef]]

Definition Classes: Conn

def qRaw(db: DatomicDb, query: String, inputs0: Seq[Any]): Collection[List[AnyRef]]

Query Datomic directly with db value and optional Scala inputs and get raw Java result.

// Sample data
Ns.str.int.get === List(
  ("Liz", 37),
  ("Ben", 42),
)

// Get some Datomic query from inspect output
Ns.str.int.inspectGet // shows datomic query...

// Paste Datomic query into `q` call and use some db value
conn.q(conn.db,
       """[:find  ?b ?c
         | :where [?a :Ns/str ?b]
         |        [?a :Ns/int ?c]]""".stripMargin)
    .toString === """[["Liz" 37], ["Ben" 42]]"""

// Modify Datomic query to see result, for instance
// by adding input to query and applying input value
conn.q(conn.db,
       """[:find  ?b ?c
         | :in    $ ?c
         | :where [?a :Ns/str ?b]
         |        [?a :Ns/int ?c]]""".stripMargin,
       Seq(42) // input values in list
 ).toString === """[["Ben" 42]]"""

db: Any Datomic Database value (could be asOf(x) etc)
query: Datomic query string
inputs0: Seq of optional input(s) to query
returns: java.util.Collection[java.util.List[AnyRef]]

Definition Classes: Conn_Client → Conn

def qRaw(query: String, inputs: Any*): Collection[List[AnyRef]]

Query Datomic directly with optional Scala inputs and get raw Java result.

// Sample data
Ns.str.int.get === List(
  ("Liz", 37),
  ("Ben", 42),
)

// Start out easily with a Datomic query from inspect output
Ns.str.int.inspectGet // shows datomic query...

// Paste Datomic query into `q` call
conn.q("""[:find  ?b ?c
         | :where [?a :Ns/str ?b]
         |        [?a :Ns/int ?c]]""".stripMargin)
    .toString === """[["Liz" 37], ["Ben" 42]]"""

// Modify Datomic query to see result, for instance
// by adding input to query and applying input value
conn.q("""[:find  ?b ?c
         | :in    $ ?c
         | :where [?a :Ns/str ?b]
         |        [?a :Ns/int ?c]]""".stripMargin, 42).toString === """[["Ben" 42]]"""

query: Datomic query string
inputs: Optional input(s) to query
returns: java.util.Collection[java.util.List[AnyRef]]

Definition Classes: Conn

def query(model: Model, query: Query): Collection[List[AnyRef]]

Query Datomic with Model and Query to get raw Java data.

Query Datomic with Model and Query to get raw Java data.

Will transparently relegate query depending on Model to:

- Datalog query execution - Datoms API accessing index - Log API accessing log

Return type (tuple matching the molecule) is the same for all 3 APIs so that application code can query and access data of all molecules the same way.

model: Model instance
query: Query instance
returns: java.util.Collection[java.util.List[AnyRef]]

Definition Classes: Conn_Client → Conn

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

def testDb(db: DatomicDb): Unit

Manually apply a database to use.

Definition Classes: Conn_Client → Conn

def testDbAsOf(d: Date): Unit

Use test database as of date.

d: Date

Definition Classes: Conn_Client → Conn

def testDbAsOf(tOrTx: Long): Unit

Use test database as of time t / tx id.

Definition Classes: Conn_Client → Conn

def testDbAsOf(txR: TxReport): Unit

Use test database as of transaction report.

txR: Transaction report

Definition Classes: Conn_Client → Conn

def testDbAsOfNow: Unit

Use test database as of now.

Definition Classes: Conn_Client → Conn

def testDbSince(d: Date): Unit

Use test database since date.

d: Date

Definition Classes: Conn_Client → Conn

def testDbSince(tOrTx: Long): Unit

Use test database since time t.

Definition Classes: Conn_Client → Conn

def testDbSince(txR: TxReport): Unit

Use test database since transaction report.

txR: Transaction report

Definition Classes: Conn_Client → Conn

def testDbWith(txDataJava: List[List[AnyRef]]): Unit

Use test database with temporary raw Java transaction data.

Definition Classes: Conn_Client → Conn

def testDbWith(txData: Seq[Seq[Statement]]*): Unit

Use test database with temporary transaction data.

Use test database with temporary transaction data.

Transaction data can be supplied from any molecule:

val benId = Person.name("Ben").save.eid

// Use temporary db with given transaction data applied
conn.testDbWith(
  Person.name("liz").getSaveTx
)

// Query using temporary database including Liz
Person.name.get === List("Ben", "Liz")

// Multiple transactions can be applied
conn.testDbWith(
  Person.name("Joe").getSaveTx,
  benId.getRetractTx
)
Person.name.get === List("Liz", "Joe")

txData: List of List of transaction Statement's

Definition Classes: Conn_Client → Conn

final def time(n: Int, prev: Int = 0): Unit

Attributes: protected
Definition Classes: Helpers

def transact(javaStmts: List[_], scalaStmts: Seq[Seq[Statement]] = Nil): TxReport

Transact edn files or other raw transaction data.

val data_rdr2 = new FileReader("examples/resources/seattle/seattle-data1a.dtm")
val rawTxStmts = Util.readAll(data_rdr2).get(0).asInstanceOf[java.util.List[Object]]

// transact
val result: TxReport = conn.transact(rawTxStmts)

javaStmts: Raw transaction data, typically from edn file.
returns: TxReport

Definition Classes: Conn_Client → Conn

def transact(scalaStmts: Seq[Seq[Statement]]): TxReport

Transact Seq of Seqs of molecule.core.ast.transactionModel.Statements

returns: TxReport

Definition Classes: Conn_Client → Conn

def transactAsync(javaStmts: List[_], scalaStmts: Seq[Seq[Statement]] = Nil)(implicit ec: ExecutionContext): Future[TxReport]

Asynchronously transact edn files or other raw transaction data.

val data_rdr2 = new FileReader("examples/resources/seattle/seattle-data1a.dtm")
val rawTxStmts = Util.readAll(data_rdr2).get(0).asInstanceOf[java.util.List[Object]]

// transact
val result: Future[TxReport] = conn.transactAsync(rawTxStmts)

javaStmts: Raw transaction data, typically from edn file.
returns: Future with TxReport with result of transaction

Definition Classes: Conn_Client → Conn

def transactAsync(scalaStmts: Seq[Seq[Statement]])(implicit ec: ExecutionContext): Future[TxReport]

Asynchronously transact Seq of Seqs of molecule.core.ast.transactionModel.Statements

returns: TxReport

Definition Classes: Conn_Client → Conn

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 useLiveDb: Unit

Get out of test mode and back to live db.

Definition Classes: Conn_Client → Conn

def usingTempDb(tempDb: TempDb): Conn

Definition Classes: Conn_Client → Conn

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

var withDbInUse: Boolean

Attributes: protected

lazy val zone: ZoneId

Definition Classes: DateHandling

Packages

Conn_Client

case class Conn_Client(client: Client, clientAsync: AsyncClient, dbName: String) extends Conn_Datomic with Helpers with BridgeDatomicFuture with Product with Serializable

Instance Constructors

Type Members

Value Members

Inherited from Serializable

Inherited from Serializable

Inherited from Product

Inherited from Equals

Inherited from BridgeDatomicFuture

Inherited from Helpers

Inherited from DateHandling

Inherited from RegexMatching

Inherited from Conn_Datomic

Inherited from Conn

Inherited from AnyRef

Inherited from Any

Ungrouped

Packages

Conn_Client 

case class Conn_Client(client: Client, clientAsync: AsyncClient, dbName: String) extends Conn_Datomic with Helpers with BridgeDatomicFuture with Product with Serializable

Instance Constructors

Type Members

Value Members

Inherited from Serializable

Inherited from Serializable

Inherited from Product

Inherited from Equals

Inherited from BridgeDatomicFuture

Inherited from Helpers

Inherited from DateHandling

Inherited from RegexMatching

Inherited from Conn_Datomic

Inherited from Conn

Inherited from AnyRef

Inherited from Any

Ungrouped

Conn_Client