Packages

package root

Documentation/API for the Molecule library - a meta DSL for the Datomic database.

Definition Classes: root

package molecule

Molecule library - a Scala meta-DSL for the Datomic database.

Definition Classes: root

package core

Definition Classes: molecule

package api

Definition Classes: core

package exception

package get

Synchronous getter methods to retrieve data from Datomic.

The Datomic On-Prem(ises) server model provides a Peer that returns data synchronously. The Peer which lives in application memory caches data aggressively and for data fitting in memory latency can be extremely low and queries return very fast. And even when access to disk is needed, clever branching is used. Memcached is also an option.

The Datomic Cloud model data returns data asynchronously. If Datomic creates a Java API for the Cloud model, Molecule could relatively easy adapt to this model too. In the meanwhile, Future-wrapped methods in this package can be used.

Molecule has 5 groups of synchronous getters, each returning data in various formats:

GetArray - fastest retrieved typed data set. Can be traversed with a fast while loop
GetIterable - for lazily traversing row by row
GetJson - data formatted as Json string
GetList - default getter returning Lists of tuples. Convenient typed data, suitable for smaller data sets
GetRaw - fastest retrieved raw un-typed data from Datomic

Getters in each of the 5 groups come with 5 time-dependent variations:

get [current data]
getAsOf
getSince
getWith
getHistory

Each time variation has various overloads taking different parameters (see each group for more info).

See also: equivalent asynchronous getters in the getAsync package.

package getAsync

Asynchronous getter methods to retrieve data from Datomic.

For convenience, all synchronous getter methods from the get package are here wrapped in Futures.

Molecule has 5 groups of asynchronous getters, each returning Futures of data in various formats:

GetAsyncArray - fastest retrieved typed data set. Can be traversed with a fast while loop
GetAsyncIterable - for lazily traversing row by row
GetAsyncJson - data formatted as Json string
GetAsyncList - default getter returning Lists of tuples. Convenient typed data, suitable for smaller data sets
GetAsyncRaw - fastest retrieved raw un-typed data from Datomic

Getters in each of the 5 groups come with 5 time-dependent variations:

getAsync [current data]
getAsyncAsOf
getAsyncSince
getAsyncWith
getAsyncHistory

Each time variation has various overloads taking different parameters (see each group for more info).

See also: equivalent synchronous getters in the get package.

Keywords

Molecule

OptionalMapOps

ShowInspect

TxBundles

TxFunctions

package ast

Internal Molecule ASTs.

Definition Classes: core

package boilerplate

Internal interfaces for auto-generated DSL boilerplate code.

Internal interfaces for auto-generated DSL boilerplate code.

Interfaces to the generated schema-defined DSL boilerplate code that the sbt-plugin generates when doing a sbt-compile. Molecule macros can then type-safely deduct the type structure of composed molecules.

Definition Classes: core

package composition

Methods to build transaction, composite and nested molecules.

Definition Classes: core

package data

Data model DSL and API.

Definition Classes: core

package exceptions

Exceptions thrown by Molecule.

Definition Classes: core

package expression

Attribute expressions and operations.

Attribute expressions and operations.

Refine attribute matches with various attribute expressions:

Person.age(42)                           // equality
Person.name.contains("John")             // fulltext search
Person.age.!=(42)                        // negation (or `not`)
Person.age.<(42)                         // comparison (< > <= >=)
Person.name("John" or "Jonas")           // OR-logic
Person.age()                             // apply empty value to retract value(s) in updates
Person.hobbies.assert("golf")               // add value(s) to card-many attributes
Person.hobbies.retract("golf")            // retract value(s) of card-many attributes
Person.hobbies.replace("golf", "diving") // replace value(s) of card-many attributes
Person.tags.k("en")                      // match values of map attributes by key
Person.age(Nil)                          // match non-asserted datoms (null)
Person.name(?)                           // initiate input molecules awaiting input at runtime
Person.name(unify)                       // Unify attributes in self-joins

Apply aggregate keywords to aggregate attribute value(s):

// Aggregates on any attribute type
Person.age(count).get.head         === 3   // count of asserted `age` attribute values
Person.age(countDistinct).get.head === 3   // count of asserted distinct `age` attribute values
Person.age(max).get.head           === 38  // maximum `age` value (using `compare`)
Person.age(min).get.head           === 5   // maximum `age` value (using `compare`)
Person.age(rand).get.head          === 25  // single random `age` value
Person.age(sample).get.head        === 27  // single sample `age` value (when single value, same as random)

// Aggregates on any attribute type, returning multiple values
Person.age(distinct).get.head  === Vector(5, 7, 38)  // distinct `age` values
Person.age(max(2)).get.head    === Vector(38, 7)     // 2 maximum `age` values
Person.age(min(2)).get.head    === Vector(5, 7)      // 2 minimum `age` values
Person.age(rand(2)).get.head   === Stream(5, ?)      // 2 random `age` values (values can re-occur)
Person.age(sample(2)).get.head === Vector(7, 38)     // 2 sample `age` values

// Aggregates on number attributes
Person.age(sum).get.head      === 50               // sum of all `age` numbers
Person.age(avg).get.head      === 16.66666667      // average of all `age` numbers
Person.age(median).get.head   === 7                // median of all `age` numbers
Person.age(stddev).get.head   === 15.107025591499  // standard deviation of all `age` numbers
Person.age(variance).get.head === 228.2222222222   // variance of all `age` numbers

Definition Classes: core

package facade

Definition Classes: core

package factory

Factory methods m to instantiate molecules from custom DSL molecule constructs.

Definition Classes: core

package generic

Definition Classes: core

package input

Definition Classes: core

package macros

Definition Classes: core

package ops

Internal operational helpers for transforming DSL to molecules.

Definition Classes: core

package transform

Internal transformers from DSL to Model/Query/Transaction/Datomic.

Internal transformers from DSL to Model/Query/Transaction/Datomic.

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

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

Definition Classes: core

package util

Internal database functions for Datomic.

Definition Classes: core

molecule.core

api

package api

Content Hierarchy

Ordering

Alphabetic

Visibility

Public
All

Type Members

trait Molecule[Tpl] extends MoleculeBase with CastHelpers[Tpl] with JsonBuilder with GetArray[Tpl] with GetIterable[Tpl] with GetList[Tpl] with GetRaw with GetJson with GetAsyncArray[Tpl] with GetAsyncIterable[Tpl] with GetAsyncList[Tpl] with GetAsyncRaw with GetAsyncJson with ShowInspect[Tpl]

Core molecule interface defining actions that can be called on molecules.

Groups of interfaces:

get	getAsync	Get molecule data.
getAsOf	getAsyncAsOf	Get molecule data asOf point in time.
getSince	getAsyncSince	Get molecule data since point in time.
getWith	getAsyncWith	Get molecule data with given data set.
getHistory	getAsyncHistory	Get molecule data from history of database.
save	saveAsync	Save molecule with applied data.
insert	insertAsync	Insert multiple rows of data matching molecule.
update	updateAsync	Update molecule with applied data.
tx		Molecule transaction data (input to `getWith`).
inspect get		Inspect calling get method on molecule.
inspect operation		Inspect calling save/insert/update method on molecule.

Tpl: Type of molecule (tuple of its attribute types)

See also: For retract ("delete") methods, see EntityOps and Entity.

trait OptionalMapOps extends AnyRef
Container of implicit for optional Map operations.
trait ShowInspect[Tpl] extends AnyRef
Inspect methods
Inspect methods
Call a inspect method on a molecule to see the internal transformations and produced transaction statements or sample data.
trait TxBundles extends AnyRef
trait TxFunctions extends AnyRef
Transactional methods for bundled transactions and tx functions

Value Members

object Keywords extends Keywords
object Molecule
Arity 1-22 molecule implementation interfaces.
object OptionalMapOps extends OptionalMapOps
Optional implicit operations for optional Map attributes
Optional implicit operations for optional Map attributes
Is not imported in the default Molecule api imports since they are rather specialized. If needed, they can be made available with the following aditional import:
```
import molecule.api.optionalMapOps._
import molecule.datomic.api._ // Standard api import with any arity
```
Since this is a rather specialized
object TxFunctions extends Helpers with BridgeDatomicFuture

Packages

api 

package api

Type Members

Value Members

Ungrouped

api