Packages

  • package root

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

    Manual | scalamolecule.org | Github | Forum

    Definition Classes
    root
  • package molecule

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

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

    See api package for various api imports to start using Molecule.

    Sub-packages

    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.

    Definition Classes
    root
  • package api

    Public interface to be imported to use Molecule.

    Public interface to be imported to use Molecule.

    To make the Molecule macro materializations as fast as possible we try to import as few macro implicits as possible. If your application code build molecules with at the most 10 attributes, then you can do the following import to start using Molecule:

    import molecule.api.out10._

    out means "output molecule" , and 10 the maximum arity or number of attributes of your molecules.

    If you use input molecules awaiting an input then you can add inX where X is how many inputs (1, 2 or 3) you will use, for instance:

    import molecule.api.in2_out10._

    This way we keep the implicit macro def lookups to a minimum and compilation speed as fast as possible.

    Arities can be changed anytime you like. But not to a lower arity than that of the molecules you use in scope of the import.

    Definition Classes
    molecule
  • package exception
    Definition Classes
    api
  • package get

    Synchronous getter methods to retrieve data from Datomic.

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

    Definition Classes
    api
    See also

    equivalent asynchronous getters in the getAsync package.

  • package getAsync

    Asynchronous getter methods to retrieve data from Datomic.

    Asynchronous getter methods to retrieve data from Datomic.

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

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

    Definition Classes
    api
    See also

    equivalent synchronous getters in the get package.

  • Entity
  • EntityOps
  • Molecule
  • OptionalMapOps
  • ShowDebug
  • TxMethods
  • core
  • in1_out1
  • in1_out10
  • in1_out11
  • in1_out12
  • in1_out13
  • in1_out14
  • in1_out15
  • in1_out16
  • in1_out17
  • in1_out18
  • in1_out19
  • in1_out2
  • in1_out20
  • in1_out21
  • in1_out22
  • in1_out3
  • in1_out4
  • in1_out5
  • in1_out6
  • in1_out7
  • in1_out8
  • in1_out9
  • in2_out1
  • in2_out10
  • in2_out11
  • in2_out12
  • in2_out13
  • in2_out14
  • in2_out15
  • in2_out16
  • in2_out17
  • in2_out18
  • in2_out19
  • in2_out2
  • in2_out20
  • in2_out21
  • in2_out22
  • in2_out3
  • in2_out4
  • in2_out5
  • in2_out6
  • in2_out7
  • in2_out8
  • in2_out9
  • in3_out1
  • in3_out10
  • in3_out11
  • in3_out12
  • in3_out13
  • in3_out14
  • in3_out15
  • in3_out16
  • in3_out17
  • in3_out18
  • in3_out19
  • in3_out2
  • in3_out20
  • in3_out21
  • in3_out22
  • in3_out3
  • in3_out4
  • in3_out5
  • in3_out6
  • in3_out7
  • in3_out8
  • in3_out9
  • out1
  • out10
  • out11
  • out12
  • out13
  • out14
  • out15
  • out16
  • out17
  • out18
  • out19
  • out2
  • out20
  • out21
  • out22
  • out3
  • out4
  • out5
  • out6
  • out7
  • out8
  • out9
o

molecule.api

in2_out2

object in2_out2 extends core with Molecule_Factory2 with Molecule_In_1_Factory2 with Molecule_In_2_Factory2 with Composite_Factory2 with Composite_In_1_Factory2 with Composite_In_2_Factory2

Ordering
  1. Grouped
  2. Alphabetic
  3. By Inheritance
Inherited
  1. in2_out2
  2. Composite_In_2_Factory2
  3. Composite_In_1_Factory2
  4. Composite_Factory2
  5. Molecule_In_2_Factory2
  6. Molecule_In_1_Factory2
  7. Molecule_Factory2
  8. core
  9. GenericVAET
  10. GenericEAVT
  11. GenericAVET
  12. GenericAEVT
  13. GenericLog
  14. GenericSchema
  15. TxMethods
  16. EntityOps
  17. LogicImplicits
  18. AggregateKeywords
  19. AttrExpressions
  20. Datomic
  21. AnyRef
  22. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Type Members

  1. type ?? = expression.AttrExpressions.?
    Definition Classes
    AttrExpressions
  2. trait avg extends AnyRef

    Average of attribute values.

    Average of attribute values.

    Apply avg keyword to attribute to return average of attribute values of entities matching the molecule.

    Match.score.insert(1, 2, 4)
    Match.score(avg).get.head === 2.3333333333333335 // (1 + 2 + 4) / 3
    returns

    Double

    Definition Classes
    AggregateKeywords
  3. trait count extends AnyRef

    Count of attribute values.

    Count of attribute values.

    Apply count keyword to attribute to return count of attribute values of entities matching the molecule.

    Person.firstName.lastName.age insert List(
      ("Ben", "Hayday", 42),
      ("Liz", "Taylor", 34),
      ("Liz", "Swifty", 34),
      ("Liz", "Mooray", 25)
    )
    Person.firstName.age(count).get === List(
      ("Ben", 1),
      ("Liz", 3) // 34, 34, 25
    )
    returns

    Int

    Definition Classes
    AggregateKeywords
  4. trait countDistinct extends AnyRef

    Count of distinct attribute values.

    Count of distinct attribute values.

    Apply countDistinct keyword to attribute to return count of distinct attribute values of entities matching the molecule.

    Person.firstName.lastName.age insert List(
      ("Ben", "Hayday", 42),
      ("Liz", "Taylor", 34),
      ("Liz", "Swifty", 34),
      ("Liz", "Mooray", 25)
    )
    Person.firstName.age(countDistinct).get === List(
      ("Ben", 1),
      ("Liz", 2) // 34, 25
    )
    returns

    Int

    Definition Classes
    AggregateKeywords
  5. trait distinct extends AnyRef

    Distinct attribute values.

    Distinct attribute values.

    Apply distinct keyword to attribute to return Vector of distinct attribute values of entities matching the molecule.

    Person.firstName.lastName.age insert List(
      ("Ben", "Hayday", 42),
      ("Liz", "Taylor", 34),
      ("Liz", "Swifty", 34),
      ("Liz", "Mooray", 25)
    )
    Person.firstName.age(distinct) insert List(
      ("Ben", 42),
      ("Liz", Vector(34, 25)) // only single 34 returned
    )
    returns

    List[attribute-type]

    Definition Classes
    AggregateKeywords
  6. trait max extends AnyRef

    Maximum attribute value(s).

    Maximum attribute value(s).

    Apply max keyword to attribute to return the maximum attribute value of entities matching the molecule.

    Person.age.insert(25, 34, 37, 42, 70)
    Person.age(max).get.head === 70

    Apply max(n) to return Vector of the n biggest values.

    Person.age(max(3)).get.head === Vector(37, 42, 70)
    Definition Classes
    AggregateKeywords
    Note

    max/max(n) supports all value types (via comparators).
    max(n) Can at most return the number of values that match.

  7. trait maxs extends AnyRef
    Definition Classes
    AggregateKeywords
  8. trait median extends AnyRef

    Median of attribute values.

    Median of attribute values.

    Apply median keyword to attribute to return median of attribute values of entities matching the molecule.

    Match.score.insert(1, 2, 4)
    Match.score(median).get.head === 2

    OBS: When it comes to an even number of values, Datomic has a special implementation of median that is different from the one described on the Wiki entry on the median function.

    Datomic calculates the median of even number of values as the average of the two middle numbers rounded down to nearest whole number

    Match.score.insert(1, 2, 3, 4)
    Match.score(median).get.head === 2 // (2 + 3) / 2 = 2.5 rounded down to 2

    With decimal numbers this can go wrong:

    Match.score.insert(1.0, 2.5, 2.5, 3.0)
    Match.score(median).get.head === 2 // (2.5 + 2.5) / 2 = 2.5 rounded down to 2 (This is wrong and bug report has been filed)
    returns

    Value of Attribute type

    Definition Classes
    AggregateKeywords
  9. trait min extends AnyRef

    Minimum attribute value(s).

    Minimum attribute value(s).

    Apply min keyword to attribute to return the minimum attribute value of entities matching the molecule.

    Person.age.insert(25, 34, 37, 42, 70)
    Person.age(min).get.head === 25

    Apply min(n) to return Vector of the n smallest values.

    Person.age(min(3)).get.head === Vector(25, 34, 37)
    Definition Classes
    AggregateKeywords
    Note

    min/min(n) supports all value types (via comparators).
    min(n) Can at most return the number of values that match.

  10. trait mins extends AnyRef
    Definition Classes
    AggregateKeywords
  11. trait rand extends AnyRef

    Random attribute value(s).

    Random attribute value(s).

    Apply random keyword to attribute to return a single random attribute of entities matching the molecule.

    Person.age.insert(25, 34, 37, 42, 70)
    Person.age(random).get.head === 34 // or other..

    Apply random(n) to return Vector of n random values. Observe though that duplicate random values can re-occur.

    Person.age(random(3)).get.head === Vector(42, 25, 42) // or other..

    To get distinct values only, use the sample(n) keyword instead.

    Definition Classes
    AggregateKeywords
  12. trait rands extends AnyRef
    Definition Classes
    AggregateKeywords
  13. trait sample extends AnyRef

    Sample attribute value(s).

    Sample attribute value(s).

    Apply sample keyword to attribute to return a single sample (random) attribute value of entities matching the molecule.

    Person.age.insert(25, 34, 37, 42, 70)
    Person.age(sample).get.head === 42 // or other..

    Apply sample(n) to return Vector of up to n distinct sample values.

    Person.age(sample(3)).get.head === Vector(70, 25, 37) // or other..

    If values don't need to be distinct, random(n) can be used also.

    Definition Classes
    AggregateKeywords
    Note

    Can at most return the number of values that match.

  14. trait samples extends AnyRef
    Definition Classes
    AggregateKeywords
  15. trait stddev extends AnyRef

    Variance of attribute values.

    Variance of attribute values.

    Apply stddev keyword to attribute to return variance of attribute values of entities matching the molecule.

    Match.score.insert(1, 2, 4)
    Match.score(stddev).get.head === 1.247219128924647
    returns

    Double

    Definition Classes
    AggregateKeywords
  16. trait sum extends AnyRef

    Sum of attribute values.

    Sum of attribute values.

    Apply sum keyword to attribute to return sum of attribute values of entities matching the molecule.

    Match.score.insert(1, 2, 4)
    Match.score(sum).get.head === 7
    returns

    Value of Attribute type

    Definition Classes
    AggregateKeywords
  17. trait variance extends AnyRef

    Variance of attribute values.

    Variance of attribute values.

    Apply variance keyword to attribute to return variance of attribute values of entities matching the molecule.

    Match.score.insert(1, 2, 4)
    Match.score(variance).get.head === 1.5555555555555556
    returns

    Double

    Definition Classes
    AggregateKeywords
  18. trait ? extends AnyRef

    Turn molecule into input molecule awaiting input.

    Turn molecule into input molecule awaiting input.

    Apply input marker ? to attribute to turn molecule into an 'input molecule'.

    At runtime the input molecule expects input for the attribute in place of the ? marker.

    // Input molecule created at compile time.
    val ageOfPersons = m(Person.name_(?).age) // awaiting name of type String
    
    // At runtime, "Ben" is applied as input replacing the `?` placeholder and we can get the age.
    ageOfPersons("Ben").get === List(42)
    Definition Classes
    AttrExpressions
    Note

    Data can only be retrieved from input molecules once they have been resolved with input.
    Input molecule queries are cached and optimized by Datomic.

  19. trait AttrExpr[Ns, T] extends AnyRef

    Expression methods common for all attributes.

    Expression methods common for all attributes.

    Definition Classes
    AttrExpressions
  20. trait FulltextExpr[Ns, In] extends AnyRef

    Expression methods of String attributes with fulltext search.

    Expression methods of String attributes with fulltext search.

    Definition Classes
    AttrExpressions
  21. trait ManyAttrExpr[Ns, Add, OldNew, Rem] extends AnyRef

    Value update methods for card-many attributes.

    Value update methods for card-many attributes.

    Definition Classes
    AttrExpressions
  22. trait ManyExpr[Ns, In, T] extends ValueAttrExpr[Ns, In, T] with ManyAttrExpr[Ns, T, (T, T), T]

    Expression methods of card-many attributes.

    Expression methods of card-many attributes.

    Definition Classes
    AttrExpressions
  23. trait MapAttrExpr[Ns, In, T] extends ValueAttrExpr[Ns, In, T] with ManyAttrExpr[Ns, (String, T), (String, T), String]

    Expression methods of map attributes.

    Expression methods of map attributes.

    Definition Classes
    AttrExpressions
  24. trait OneExpr[Ns, In, T] extends ValueAttrExpr[Ns, In, T]

    Expression methods of card-one attributes.

    Expression methods of card-one attributes.

    Definition Classes
    AttrExpressions
  25. trait OptionalExpr[Ns, T] extends AnyRef

    Expression methods of optional attributes.

    Expression methods of optional attributes.

    Definition Classes
    AttrExpressions
  26. trait ValueAttrExpr[Ns, In, T] extends AttrExpr[Ns, T]

    Expression methods of value attributes.

    Expression methods of value attributes.

    Definition Classes
    AttrExpressions
  27. trait unify extends AnyRef

    Unify attribute value in self-join.

    Unify attribute value in self-join.

    Apply unify marker to attribute to unify its value with previous values of the same attribute in the molecule in a self-join.

    m(Person.age.name.Beverages * Beverage.name.rating) insert List(
        (23, "Joe", List(("Coffee", 3), ("Cola", 2), ("Pepsi", 3))),
        (25, "Ben", List(("Coffee", 2), ("Tea", 3))),
        (23, "Liz", List(("Coffee", 1), ("Tea", 3), ("Pepsi", 1))))
    
    // What beverages do pairs of 23- AND 25-year-olds like in common?
    // Drink name is unified - Joe and Ben both drink coffee, etc..
    Person.age_(23).name.Beverages.name._Ns.Self
          .age_(25).name.Beverages.name_(unify).get.sorted === List(
      ("Joe", "Coffee", "Ben"),
      ("Liz", "Coffee", "Ben"),
      ("Liz", "Tea", "Ben")
    )
    Definition Classes
    AttrExpressions

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  5. implicit final def bigDec2Model(v: BigDecimal): TermValue[BigDecimal]

    Definition Classes
    LogicImplicits
  6. implicit final def bigDecSet2Model(set: Set[BigDecimal]): TermValue[Set[BigDecimal]]

    Definition Classes
    LogicImplicits
  7. implicit final def bigInt2Model(v: BigInt): TermValue[BigInt]

    Definition Classes
    LogicImplicits
  8. implicit final def bigIntSet2Model(set: Set[BigInt]): TermValue[Set[BigInt]]

    Definition Classes
    LogicImplicits
  9. implicit final def boolean2Model(v: Boolean): TermValue[Boolean]

    Definition Classes
    LogicImplicits
  10. implicit final def booleanSet2Model(set: Set[Boolean]): TermValue[Set[Boolean]]

    Definition Classes
    LogicImplicits
  11. def clone(): AnyRef
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @native() @throws( ... )
  12. implicit final def date2Model(v: Date): TermValue[Date]

    Definition Classes
    LogicImplicits
  13. implicit final def dateSet2Model(set: Set[Date]): TermValue[Set[Date]]

    Definition Classes
    LogicImplicits
  14. def debugRetract(eids: Iterable[Long], txMetaDataMolecules: MoleculeBase*)(implicit conn: Conn): Unit

    Debug retracting multiple entities with optional transaction meta data.

    Debug retracting multiple entities with optional transaction meta data.

    Without affecting the database, a multiple entity retract action can be debugged by adding a 'D' (for 'Debug') to the retract method.

    Here we debug a possible retraction of two comment entities with transaction meta data asserting that the retraction was done by Ben Goodman:

    debugRetract(Seq(commentEid1, commentEid2), MetaData.user("Ben Goodman"))

    This will print debugging info about the retraction to output (without affecting the database):

    ## 1 ## molecule.Datomic.debugRetract
    ===================================================================================================================
    1      Model(
      1      TxMetaData(
        1      Atom(metaData,user,String,1,Eq(List(Ben Goodman)),None,List(),List())))
    ------------------------------------------------
    2      List(
      1      :db/add     'tx                             :MetaData/user     Values(Eq(List(Ben Goodman)),None)   Card(1))
    ------------------------------------------------
    3      List(
      1      List(
        1      :db.fn/retractEntity   17592186045445
        2      :db.fn/retractEntity   17592186045446
        3      :db/add   #db/id[:db.part/tx -1000097]    :MetaData/user     b                                    Card(1)))
    ===================================================================================================================
    eids

    Iterable of entity ids of type Long

    txMetaDataMolecules

    Zero or more transaction meta data molecules

    conn

    Implicit Conn value in scope

    returns

    Unit (prints to output)

    Definition Classes
    EntityOps
  15. macro def debugTransact(txFnCall: Seq[Seq[Statement]], txMolecules: MoleculeBase*): Unit

    Debug tx function invocation

    Print transaction statements to output of a tx function invocation without affecting the live database.

    Debug tx function invocation

    Print transaction statements to output of a tx function invocation without affecting the live database.

    // Print debug info for tx function invocation
    debugTransact(transfer(fromAccount, toAccount, 20))
    
    // Prints produced tx statements to output:
    /*
    ## 1 ## TxReport
    ========================================================================
    1          ArrayBuffer(
      1          List(
        1          :db/add       17592186045445       :Account/balance    80        Card(1))
      2          List(
        1          :db/add       17592186045447       :Account/balance    720       Card(1)))
    ------------------------------------------------
    2          List(
      1    1     added: true ,   t: 13194139534345,   e: 13194139534345,   a: 50,   v: Thu Nov 22 16:23:09 CET 2018
    
      2    2     added: true ,   t: 13194139534345,   e: 17592186045445,   a: 64,   v: 80
           3     added: false,  -t: 13194139534345,  -e: 17592186045445,  -a: 64,  -v: 100
    
      3    4     added: true ,   t: 13194139534345,   e: 17592186045447,   a: 64,   v: 720
           5     added: false,  -t: 13194139534345,  -e: 17592186045447,  -a: 64,  -v: 700)
    ========================================================================
    */
    txFnCall

    Tx function invocation

    txMolecules

    Optional tx meta data molecules

    Definition Classes
    TxMethods
  16. def debugTransact(stmtss: Seq[Seq[Statement]]*)(implicit conn: Conn): Unit

    Debug bundled transaction statements

    Add transaction statements from one or more molecule actions to debugTransact to see the bundled transaction statements.

    Debug bundled transaction statements

    Add transaction statements from one or more molecule actions to debugTransact to see the bundled transaction statements.

    debugTransact(
      // retract
      e1.getRetractTx,
      // save
      Ns.int(4).getSaveTx,
      // insert
      Ns.int.getInsertTx(List(5, 6)),
      // update
      Ns(e2).int(20).getUpdateTx
    )
    
    // Prints transaction data to output:
    /*
      ## 1 ## TxReport
      ========================================================================
      1          ArrayBuffer(
        1          List(
          1          :db.fn/retractEntity   17592186045445)
        2          List(
          1          :db/add       #db/id[:db.part/user -1000247]     :Ns/int          4           Card(1))
        3          List(
          1          :db/add       #db/id[:db.part/user -1000252]     :Ns/int          5           Card(1))
        4          List(
          1          :db/add       #db/id[:db.part/user -1000253]     :Ns/int          6           Card(1))
        5          List(
          1          :db/add       17592186045446                     :Ns/int          20          Card(1)))
      ------------------------------------------------
      2          List(
        1    1     added: true ,   t: 13194139534345,   e: 13194139534345,   a: 50,   v: Wed Nov 14 23:38:15 CET 2018
    
        2    2     added: false,  -t: 13194139534345,  -e: 17592186045445,  -a: 64,  -v: 1
    
        3    3     added: true ,   t: 13194139534345,   e: 17592186045450,   a: 64,   v: 4
    
        4    4     added: true ,   t: 13194139534345,   e: 17592186045451,   a: 64,   v: 5
    
        5    5     added: true ,   t: 13194139534345,   e: 17592186045452,   a: 64,   v: 6
    
        6    6     added: true ,   t: 13194139534345,   e: 17592186045446,   a: 64,   v: 20
             7     added: false,  -t: 13194139534345,  -e: 17592186045446,  -a: 64,  -v: 2)
      ========================================================================
    */
    stmtss

    Statement's from multiple molecule operations

    conn

    Implicit Conn value in scope

    Definition Classes
    TxMethods
  17. implicit final def double2Model(v: Double): TermValue[Double]

    Definition Classes
    LogicImplicits
  18. implicit final def doubleSet2Model(set: Set[Double]): TermValue[Set[Double]]

    Definition Classes
    LogicImplicits
  19. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  20. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  21. def finalize(): Unit
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  22. implicit final def float2Model(v: Float): TermValue[Float]

    Definition Classes
    LogicImplicits
  23. implicit final def floatSet2Model(set: Set[Float]): TermValue[Set[Float]]

    Definition Classes
    LogicImplicits
  24. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  25. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  26. implicit final def int2Model(v: Int): TermValue[Int]

    Definition Classes
    LogicImplicits
  27. implicit final def intSet2Model(set: Set[Int]): TermValue[Set[Int]]

    Definition Classes
    LogicImplicits
  28. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  29. implicit final def long2Entity(id: Long)(implicit conn: Conn): Entity

    Long -> Entity api implicit.

    Long -> Entity api implicit.

    Convenience implicit to allow calling Entity methods directly on entity Long value.

    // Get entity id of Ben
    val benId = Person.e.name_("Ben").get.head
    
    // Retract Ben entity directly on his entity id
    benId.retract
    id

    Entity id of type Long

    conn

    Implicit Conn value in scope

    Definition Classes
    EntityOps
  30. implicit final def long2Model(v: Long): TermValue[Long]

    Definition Classes
    LogicImplicits
  31. implicit final def longSet2Model(set: Set[Long]): TermValue[Set[Long]]

    Definition Classes
    LogicImplicits
  32. macro def m[I1, I2, T1, T2](dsl: Composite_In_2_02[I1, I2, T1, T2]): InputMolecule_2_02[I1, I2, T1, T2]

    Macro creation of composite input molecule awaiting 2 inputs from user-defined DSL with 2 output groups (arity 2).

    Macro creation of composite input molecule awaiting 2 inputs from user-defined DSL with 2 output groups (arity 2).

    The builder pattern is used to add one or more attributes to an initial namespace like Person from the example below. Further non-related attributes can be tied together with the + method to form "composite molecules" that is basically just attributes sharing the same entity id.

    Applying the ? marker to attributes changes the semantics of the composite molecule to become a "composite input molecule" that awaits input at runtime for the attributes marked with ?.

    Once the composite input molecule models the desired data structure and has been resolved with input we can call various actions on it, like get that retrieves matching data from the database.

    // Apply `?` to `age` and `score` attributes to create composite input molecule
    val personsAgeScore = m(Person.name.age_(?) + Tag.score(?))
    
    // At runtime, `age` and `score` values are applied to get the Person's name
    personsAgeScore(42, 7).get.head === ("Ben", 7)

    Composite input molecules of arity 2 has two sub-molecules with output attribute(s). If a sub-molecule has multiple output attributes, a tuple is returned, otherwise just the single value. The two groups of either a single type or tuple are then tied together in an outer composite tuple:

    Composite input molecule          Composite type (2 output groups)
    
    A.a1(?)    + B.b1(?)        =>    (a1, b1)
    A.a1(?)    + B.b1(?).b2     =>    (a1, (b1, b2))
    A.a1.a2(?) + B.b1(?)        =>    ((a1, a2), b1)
    A.a1.a2(?) + B.b1(?).b2     =>    ((a1, a2), (b1, b2)) etc...
    
    We could even have additional non-output sub-molecules:
    A.a1.a2 + B.b1(?).b2 + C.c1_(?)     =>    ((a1, a2), (b1, b2)) etc...

    Translating into the example:

    m(Person.name(?)     + Tag.score(?)      )("Ben", 7).get.head === ("Ben", 7)
    m(Person.name(?)     + Tag.score(?).flags)("Ben", 7).get.head === ("Ben", (7, 3))
    m(Person.name.age(?) + Tag.score(?)      )(42, 7)   .get.head === (("Ben", 42), 7)
    m(Person.name.age(?) + Tag.score(?).flags)(42, 7)   .get.head === (("Ben", 42), (7, 3))
    
    m(Person.name.age +
      Tag.score(?).flags +
      Cat.name_(?))(7, "pitcher").get.head === (("Ben", 42), (7, 3))
    I1

    Type of input attribute 1 (name: String or age: Int)

    I2

    Type of input attribute 2 (score: Int)

    T1

    Type of output group 1

    T2

    Type of output group 2

    dsl

    User-defined DSL structure modelling the composite input molecule awaiting 2 inputs

    returns

    Composite input molecule awaiting 2 inputs

    Definition Classes
    Composite_In_2_Factory2
  33. macro def m[I1, I2, T1](dsl: Composite_In_2_01[I1, I2, T1]): InputMolecule_2_01[I1, I2, T1]

    Macro creation of composite input molecule awaiting 2 inputs from user-defined DSL with 1 output group (arity 1).

    Macro creation of composite input molecule awaiting 2 inputs from user-defined DSL with 1 output group (arity 1).

    The builder pattern is used to add one or more attributes to an initial namespace like Person from the example below. Further non-related attributes can be tied together with the + method to form "composite molecules" that is basically just attributes sharing the same entity id.

    Applying the ? marker to attributes changes the semantics of the composite molecule to become a "composite input molecule" that awaits input at runtime for the attributes marked with ?.

    Once the composite input molecule models the desired data structure and has been resolved with input we can call various actions on it, like get that retrieves matching data from the database.

    // Apply `?` to `age` and `score` attributes to create composite input molecule
    val personsAgeScore = m(Person.name.age_(?) + Tag.score_(?))
    
    // At runtime, `age` and `score` values are applied to get the Person's name
    personsAgeScore(42, 7).get.head === "Ben"

    Composite input molecules of arity 1 has only one sub-molecule with output attribute(s). If the sub-molecule has multiple output attributes, a tuple is returned, otherwise just the single value:

    Composite input molecule            Composite type (1 output group)
    
    A.a1(?)       + B.b1_(?)      =>    a1
    A.a1.a2(?)    + B.b1_(?)      =>    (a1, a2)
    A.a1.a2.a3(?) + B.b1_(?)      =>    (a1, a2, a3)
    
    A.a1_(?) + B.b1(?)            =>    b1
    A.a1_(?) + B.b1.b2(?)         =>    (b1, b2)
    A.a1_(?) + B.b1.b2.b3(?)      =>    (b1, b2, b3)
    
    We could even have multiple tacit sub-molecules with multiple tacit attributes
    A.a1_(?).a2_ + B.b1_(?) + C.c1.c2_.c3     =>    (c1, c3)

    So, given 2 output attributes, a tuple is returned:

    m(Person.name.age(?) + Tag.score_(?))(42, 7).get.head === ("Ben", 42)
    //  A   . a1 . a2(?) +  B .   b1_(?)                   => (  a1 , a2)
    I1

    Type of input attribute 1 (age: Int)

    I2

    Type of input attribute 2 (score: Int)

    T1

    Type of output group

    dsl

    User-defined DSL structure modelling the composite input molecule awaiting 2 inputs

    returns

    Composite input molecule awaiting 2 inputs

    Definition Classes
    Composite_In_2_Factory2
  34. macro def m[I1, T1, T2](dsl: Composite_In_1_02[I1, T1, T2]): InputMolecule_1_02[I1, T1, T2]

    Macro creation of composite input molecule awaiting 1 input from user-defined DSL with 2 output groups (arity 2).

    Macro creation of composite input molecule awaiting 1 input from user-defined DSL with 2 output groups (arity 2).

    The builder pattern is used to add one or more attributes to an initial namespace like Person from the example below. Further non-related attributes can be tied together with the + method to form "composite molecules" that is basically just attributes sharing the same entity id.

    Applying the ? marker to an attribute changes the semantics of the composite molecule to become a "composite input molecule" that awaits input at runtime for the attribute marked with ?.

    Once the composite input molecule models the desired data structure and has been resolved with input we can call various actions on it, like get that retrieves matching data from the database.

    // Apply `?` to `score` attribute to create composite input molecule
    val personsWithScore = m(Person.name + Tag.score(?))
    
    // At runtime, a `score` value is applied to get the Person's name
    personsWithScore(7).get.head === ("Ben", 7)

    Composite input molecules of arity 2 has two sub-molecules with output attribute(s). If a sub-molecule has multiple output attributes, a tuple is returned, otherwise just the single value. The two groups of either a single type or tuple are then tied together in an outer composite tuple:

    Composite input molecule          Composite type (2 output groups)
    
    A.a1    + B.b1(?)           =>    (a1, b1)
    A.a1    + B.b1(?).b2        =>    (a1, (b1, b2))
    A.a1.a2 + B.b1(?)           =>    ((a1, a2), b1)
    A.a1.a2 + B.b1(?).b2        =>    ((a1, a2), (b1, b2)) etc...
    
    We could even have additional non-output sub-molecules:
    A.a1.a2 + B.b1.b2 + C.c1_(?)     =>    ((a1, a2), (b1, b2)) etc...

    Translating into the example:

    m(Person.name     + Tag.score(?)      )(7).get.head === ("Ben", 7)
    m(Person.name     + Tag.score(?).flags)(7).get.head === ("Ben", (7, 3))
    m(Person.name.age + Tag.score(?)      )(7).get.head === (("Ben", 42), 7)
    m(Person.name.age + Tag.score(?).flags)(7).get.head === (("Ben", 42), (7, 3))
    
    m(Person.name.age +
      Tag.score.flags +
      Cat.name_(?))("pitcher").get.head === (("Ben", 42), (7, 3))
    I1

    Type of input attribute 1 (score: Int)

    T1

    Type of output group 1

    T2

    Type of output group 2

    dsl

    User-defined DSL structure modelling the composite input molecule awaiting 1 input

    returns

    Composite input molecule awaiting 1 input

    Definition Classes
    Composite_In_1_Factory2
  35. macro def m[I1, T1](dsl: Composite_In_1_01[I1, T1]): InputMolecule_1_01[I1, T1]

    Macro creation of composite input molecule awaiting 1 input from user-defined DSL with 1 output group (arity 1).

    Macro creation of composite input molecule awaiting 1 input from user-defined DSL with 1 output group (arity 1).

    The builder pattern is used to add one or more attributes to an initial namespace like Person from the example below. Further non-related attributes can be tied together with the + method to form "composite molecules" that is basically just attributes sharing the same entity id.

    Applying the ? marker to an attribute changes the semantics of the composite molecule to become a "composite input molecule" that awaits input at runtime for the attribute marked with ?.

    Once the composite input molecule models the desired data structure and has been resolved with input we can call various actions on it, like get that retrieves matching data from the database.

    // Apply `?` to `score` attribute to create composite input molecule
    val personsWithScore = m(Person.name + Tag.score_(?))
    
    // At runtime, a `score` value is applied to get the Person's name
    personsWithScore(7).get.head === "Ben"

    Composite input molecules of arity 1 has only one sub-molecule with output attribute(s). If the sub-molecule has multiple output attributes, a tuple is returned, otherwise just the single value:

    Composite input molecule         Composite type (1 output group)
    
    A.a1       + B.b1_(?)      =>    a1
    A.a1.a2    + B.b1_(?)      =>    (a1, a2)
    A.a1.a2.a3 + B.b1_(?)      =>    (a1, a2, a3)
    
    A.a1_(?) + B.b1            =>    b1
    A.a1_(?) + B.b1.b2         =>    (b1, b2)
    A.a1_(?) + B.b1.b2.b3      =>    (b1, b2, b3)
    
    We could even have multiple tacit sub-molecules with multiple tacit attributes
    A.a1_(?).a2_ + B.b1_ + C.c1.c2_.c3     =>    (c1, c3)

    So, given two output attributes, a tuple is returned:

    m(Person.name.age + Tag.score_(?))(7).get.head === ("Ben", 42)
    //  A   . a1 . a2 +  B .   b1_(?)               => (  a1 , a2)
    I1

    Type of input attribute 1 (score: Int)

    T1

    Type of output group

    dsl

    User-defined DSL structure modelling the composite input molecule awaiting 1 input

    returns

    Composite input molecule awaiting 1 input

    Definition Classes
    Composite_In_1_Factory2
  36. implicit final macro def m[T1, T2](dsl: Composite02[T1, T2]): Molecule02[T1, T2]

    Macro creation of composite molecule from user-defined DSL structure with 2 output groups.

    Macro creation of composite molecule from user-defined DSL structure with 2 output groups.

    The builder pattern is used to add one or more attributes to an initial namespace like Person from the example below. Further non-related attributes can be tied together with the + method to form "composite molecules" that is basically just attributes sharing the same entity id.

    Once the composite molecule models the desired data structure we can call various actions on it, like get that retrieves matching data from the database.

    // Explicitly calling `m` to create composite molecule with 2 output attributes
    m(Person.name + Tag.score).get.head === ("Ben", 7)
    
    // Alternatively we can create the composite molecule implicitly
    Person.name.+(Tag.score).get.head === ("Ben", 7)

    Composite molecules of arity 2 has two sub-molecules with output attribute(s). If a sub-molecule has multiple output attributes, a tuple is returned, otherwise just the single value. The two groups of either a single type or tuple are then tied together in an outer composite tuple:

    Composite molecule          Composite type (2 output groups)
    
    A.a1    + B.b1        =>    (a1, b1)
    A.a1    + B.b1.b2     =>    (a1, (b1, b2))
    A.a1.a2 + B.b1        =>    ((a1, a2), b1)
    A.a1.a2 + B.b1.b2     =>    ((a1, a2), (b1, b2)) etc...
    
    We could even have additional non-output sub-molecules:
    A.a1.a2 + B.b1.b2 + C.c1_     =>    ((a1, a2), (b1, b2)) etc...

    Translating into the example:

    m(Person.name + Tag.score.flags).get.head                         === ("Ben", (7, 3))
    m(Person.name.age + Tag.score).get.head                           === (("Ben", 42), 7)
    m(Person.name.age + Tag.score.flags).get.head                     === (("Ben", 42), (7, 3))
    
    m(Person.name.age +
      Tag.score.flags +
      Cat.name_("pitcher")).get.head === (("Ben", 42), (7, 3))
    T1

    Type of output group 1

    T2

    Type of output group 2

    dsl

    User-defined DSL structure modelling the composite molecule

    returns

    Composite molecule

    Definition Classes
    Composite_Factory2
  37. implicit final macro def m[T1](dsl: Composite01[T1]): Molecule01[T1]

    Macro creation of composite molecule from user-defined DSL structure with 1 output group.

    Macro creation of composite molecule from user-defined DSL structure with 1 output group.

    The builder pattern is used to add one or more attributes to an initial namespace like Person from the example below. Further non-related attributes can be tied together with the + method to form "composite molecules" that is basically just attributes sharing the same entity id.

    Once the composite molecule models the desired data structure we can call various actions on it, like get that retrieves matching data from the database.

    // Explicitly calling `m` to create composite molecule
    // with 1 output attribute (`name`) and 1 tacit attribute (`score`).
    m(Person.name + Tag.score_).get.head === "Ben"
    
    // Alternatively we can create the composite molecule implicitly
    Person.name.+(Tag.score_).get.head === "Ben"

    Composite molecules of arity 1 has only one sub-molecule with output attribute(s). If the sub-molecule has multiple output attributes, a tuple is returned, otherwise just the single value:

    Composite molecule           Composite type (1 output group)
    
    A.a1       + B.b1_     =>    a1
    A.a1.a2    + B.b1_     =>    (a1, a2)
    A.a1.a2.a3 + B.b1_     =>    (a1, a2, a3) etc...
    
    A.a1_ + B.b1           =>    b1
    A.a1_ + B.b1.b2        =>    (b1, b2)
    A.a1_ + B.b1.b2.b3)    =>    (b1, b2, b3) etc...
    
    We could even have multiple tacit sub-molecules with multiple tacit attributes
    A.a1_.a2_ + B.b1_ + C.c1.c2_.c3     =>    (c1, c3) etc...

    So, given two output attributes, a tuple is returned:

    m(Person.name.age + Tag.score_).get.head === ("Ben", 42)
    //  A   . a1 . a2 +  B .  b1              => (  a1 , a2)
    T1

    Type of output group 1

    dsl

    User-defined DSL structure modelling the composite molecule

    returns

    Composite molecule

    Definition Classes
    Composite_Factory2
  38. macro def m[I1, I2, A, B](dsl: IN2_02[I1, I2, A, B]): InputMolecule_2_02[I1, I2, A, B]

    Macro creation of input molecule awaiting 2 inputs from user-defined DSL structure with 2 output attributes (arity 2).

    Macro creation of input molecule awaiting 2 inputs from user-defined DSL structure with 2 output attributes (arity 2).

    Molecules are build by adding one or more attributes to an initial namespace like Person from the example below.

    Applying the ? marker to attributes changes the semantics of a molecule to become an "input molecule" that awaits input at runtime for the attributes marked with ?.

    Once the input molecule has been resolved with input, we can call various actions on it, like get that retrieves matching data from the database.

    // Apply `?` to `age` and `score` attributes to create input molecule.
    // Input attributes can be tacit or mandatory
    val personAgeScore = m(Person.name.age_(?).score(?))
    
    // At runtime `age` and `score` values are applied to get the Person's name and score.
    // Since `score` was mandatory (without underscore), its value is also returned.
    personAgeScore(42, 7).get.head === ("Ben", 7)
    I1

    Type of input attribute 1 (age: Int)

    I2

    Type of input attribute 2 (score: Int)

    A

    Type of output attribute 1 (name: String)

    B

    Type of output attribute 2 (score: Int)

    dsl

    User-defined DSL structure modelling the input molecule

    returns

    Input molecule ready to be resolved

    Definition Classes
    Molecule_In_2_Factory2
  39. macro def m[I1, I2, A](dsl: IN2_01[I1, I2, A]): InputMolecule_2_01[I1, I2, A]

    Macro creation of input molecule awaiting 2 inputs from user-defined DSL structure with 1 output attribute (arity 1).

    Macro creation of input molecule awaiting 2 inputs from user-defined DSL structure with 1 output attribute (arity 1).

    Molecules are build by adding one or more attributes to an initial namespace like Person from the example below.

    Applying the ? marker to attributes changes the semantics of a molecule to become an "input molecule" that awaits input at runtime for the attributes marked with ?.

    Once the input molecule has been resolved with input, we can call various actions on it, like get that retrieves matching data from the database.

    // Apply `?` to `age` and `score` attributes to create input molecule.
    val personAgeScore = m(Person.name.age_(?).score_(?))
    
    // At runtime `age` and `score` values are applied to get the Person's name.
    personAgeScore(42, 7).get.head === "Ben"

    For arity-many molecules, data structures are returned as tuples. But for arity-1 molecules (like the example having only 1 output attribute, name) there's no need for a tuple, so values type-safely matching the attribute are returned directly in the list.

    I1

    Type of input attribute 1 (age: Int)

    I2

    Type of input attribute 2 (score: Int)

    A

    Type of output attribute 1 (name: String)

    dsl

    User-defined DSL structure modelling the input molecule

    returns

    Input molecule ready to be resolved

    Definition Classes
    Molecule_In_2_Factory2
  40. macro def m[I1, A, B](dsl: IN1_02[I1, A, B]): InputMolecule_1_02[I1, A, B]

    Macro creation of input molecule awaiting 1 input from user-defined DSL structure with 2 output attributes (arity 2).

    Macro creation of input molecule awaiting 1 input from user-defined DSL structure with 2 output attributes (arity 2).

    Molecules are build by adding one or more attributes to an initial namespace like Person from the example below.

    Applying the ? marker to an attribute changes the semantics of a molecule to become an "input molecule" that awaits input at runtime for the attribute marked with ?.

    Once the input molecule has been resolved with input, we can call various actions on it, like get that retrieves matching data from the database.

    // Apply `?` to `age` attribute to create input molecule
    val personOfAge = m(Person.name.age_(?).score)
    
    // At runtime, an `age` value is applied to get the Person's name and score
    personOfAge(42).get.head === ("Ben", 7)
    I1

    Type of input attribute 1 (age: Int)

    A

    Type of output attribute 1 (name: String)

    B

    Type of output attribute 2 (score: Int)

    dsl

    User-defined DSL structure modelling the input molecule

    returns

    Input molecule ready to be resolved

    Definition Classes
    Molecule_In_1_Factory2
  41. macro def m[I1, A](dsl: IN1_01[I1, A]): InputMolecule_1_01[I1, A]

    Macro creation of input molecule awaiting 1 input from user-defined DSL structure with 1 output attribute (arity 1).

    Macro creation of input molecule awaiting 1 input from user-defined DSL structure with 1 output attribute (arity 1).

    Molecules are build by adding one or more attributes to an initial namespace like Person from the example below.

    Applying the ? marker to an attribute changes the semantics of a molecule to become an "input molecule" that awaits input at runtime for the attribute marked with ?.

    Once the input molecule has been resolved with input, we can call various actions on it, like get that retrieves matching data from the database.

    // Apply `?` to `age` attribute to create input molecule
    val personOfAge = m(Person.name.age_(?))
    
    // At runtime, an `age` value is applied to get the Person's name
    personOfAge(42).get.head === "Ben"

    For arity-many molecules, data structures are returned as tuples. But for arity-1 molecules (like the example having only 1 output attribute, name) there's no need for a tuple, so values type-safely matching the attribute are returned directly in the list.

    I1

    Type of input attribute 1 (age: Int)

    A

    Type of output attribute 1 (name: String)

    dsl

    User-defined DSL structure modelling the input molecule

    returns

    Input molecule ready to be resolved

    Definition Classes
    Molecule_In_1_Factory2
  42. implicit final macro def m[A, B](dsl: NS02[A, B]): Molecule02[A, B]

    Macro creation of molecule from user-defined DSL structure with 2 output attributes.

    Macro creation of molecule from user-defined DSL structure with 2 output attributes.

    Molecules can be created explicitly or implicitly by building a DSL structure using boilerplate code generated from the schema definition file.

    The builder pattern is used to add one or more attributes to an initial namespace like Person from the example below. Once the molecule models the desired data structure we can call various actions on it, like get that retrieves matching data from the database.

    Data structures are returned as tuples of values type-safely matching the molecule attribute types

    // Explicitly calling `m` to create Person molecule with 2 attributes
    m(Person.name.age).get.head === ("Ben", 42)
    
    // Molecule implicitly created so we can call `get`
    Person.name.age.get.head === ("Ben", 42)
    A

    Type of output attribute 1 (name: String)

    B

    Type of output attribute 2 (age: Int)

    dsl

    User-defined DSL structure modelling the molecule

    returns

    Molecule of arity-2 typed to two attributes (Molecule02[A, B])

    Definition Classes
    Molecule_Factory2
  43. implicit final macro def m[A](dsl: NS01[A]): Molecule01[A]

    Macro creation of molecule from user-defined DSL structure with 1 output attribute.

    Macro creation of molecule from user-defined DSL structure with 1 output attribute.

    Molecules can be created explicitly or implicitly by building a DSL structure using boilerplate code generated from the schema definition file.

    The builder pattern is used to add one or more attributes to an initial namespace like Person from the example below. Once the molecule models the desired data structure we can call various actions on it, like get that retrieves matching data from the database.

    // Explicitly calling `m` to create Person molecule with 1 output attribute
    m(Person.name).get === List("Ben")
    
    // Molecule implicitly created so we can call `get`
    Person.name.get.head === "Ben"

    For arity-many molecules, data structures are returned as tuples. But for arity-1 molecules (like the example having only 1 output attribute, name) there's no need for a tuple, so values type-safely matching the attribute are returned directly in the list.

    A

    Type of output attribute 1 (name: String)

    dsl

    User-defined DSL structure modelling the molecule

    returns

    Molecule of arity-1 typed to first attribute (Molecule01[A])

    Definition Classes
    Molecule_Factory2
  44. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  45. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  46. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  47. def recreateDbFrom(schema: SchemaTransaction, identifier: String = "", protocol: String = "mem"): Conn

    Deletes existing database (!) and creates a new empty db with schema from Schema Transaction file.

    Deletes existing database (!) and creates a new empty db with schema from Schema Transaction file.

    A typical development cycle in the initial stages of creating the db schema:

    1. Edit schema definition file
    2. sbt compile to update boilerplate code in generated jars
    3. Obtain a fresh connection to new empty db with updated schema:
      implicit val conn = recreateDbFrom(YourDomainSchema)
    schema

    Auto-generated YourDomainSchema Transaction object
    (in package yourdomain.schema of generated source jar)

    identifier

    Optional String identifier to name database (default empty string creates a randomUUID)

    protocol

    Datomic protocol. Defaults to "mem" for in-memory database.

    returns

    Conn

    Definition Classes
    Datomic
  48. def recreateDbFromRaw(schemaData: List[_], identifier: String = "", protocol: String = "mem"): Conn

    Deletes existing database (!) and creates a new empty db with schema from schema data structure.

    Deletes existing database (!) and creates a new empty db with schema from schema data structure.

    Schema data structure is a java List of Map's of key/value pairs defining the schema.

    Can be an EDN file like the mbrainz example.

    schemaData

    java.util.List of java.util.Maps of key/values defining a Datomic schema

    identifier

    Optional String identifier to name database (default empty string creates a randomUUID)

    protocol

    Datomic protocol. Defaults to "mem" for in-memory database.

    returns

    Conn

    Definition Classes
    Datomic
    See also

    https://docs.datomic.com/on-prem/data-structure-literals.html

  49. def retract(eids: Iterable[Long], txMetaDataMolecules: MoleculeBase*)(implicit conn: Conn): TxReport

    Retract multiple entities with optional transaction meta data.

    Retract multiple entities with optional transaction meta data.

    0 or more transaction meta data molecules can be asserted together with a retraction of entities.

    Here we retract two comment entities with transaction meta data asserting that the retraction was done by Ben Goodman:

    retract(Seq(commentEid1, commentEid2), MetaData.user("Ben Goodman"))

    We can then later see what comments Ben Goodman retracted (op_(false)):

    Comment.e.text.op_(false).Tx(MetaData.user_("Ben Goodman")).getHistory === List(
      (commentEid1, "I like this"),
      (commentEid2, "I hate this")
    )
    eids

    Iterable of entity ids of type Long

    txMetaDataMolecules

    Zero or more transaction meta data molecules

    conn

    Implicit Conn value in scope

    returns

    TxReport with result of retract

    Definition Classes
    EntityOps
    See also

    Manual | Test

  50. def retractAsync(eids: Iterable[Long], txMetaDataMolecules: MoleculeBase*)(implicit conn: Conn, ec: ExecutionContext): Future[TxReport]

    Asynchronously retract multiple entities with optional transaction meta data.

    Asynchronously retract multiple entities with optional transaction meta data.

    0 or more transaction meta data molecules can be asserted together with a retraction of entities.

    Here we asynchronously retract two comment entities with transaction meta data asserting that the retraction was done by Ben Goodman:

    retractAsync(Seq(commentEid1, commentEid2), MetaData.user("Ben Goodman"))

    We can then later see what comments Ben Goodman retracted (op_(false)):

    Comment.e.text.op_(false).Tx(MetaData.user_("Ben Goodman")).getHistory === List(
      (commentEid1, "I like this"),
      (commentEid2, "I hate this")
    )
    eids

    Iterable of entity ids of type Long

    txMetaDataMolecules

    Zero or more transaction meta data molecules

    conn

    Implicit Conn value in scope

    returns

    TxReport with result of retract

    Definition Classes
    EntityOps
    See also

    Manual | Test

  51. implicit final def string2Model(v: String): TermValue[String]

    Definition Classes
    LogicImplicits
  52. implicit final def stringSet2Model(set: Set[String]): TermValue[Set[String]]

    Definition Classes
    LogicImplicits
  53. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  54. def toString(): String
    Definition Classes
    AnyRef → Any
  55. macro def transact(txFnCall: Seq[Seq[Statement]], txMolecules: MoleculeBase*): TxReport

    Transact tx function invocation

    Macro that takes a tx function invocation itself as its argument.

    Transact tx function invocation

    Macro that takes a tx function invocation itself as its argument. The tx function is analyzed by the macro and the necessary transaction preparations done at compile time.

    At runtime, the returned statements from the tx function is transacted as one atomic transaction.

    val txReport = transact(transfer(fromAccount, toAccount, 20))

    Transaction meta data molecules can be added

    // Add tx meta data that John did the transfer and that it is a scheduled transfer
    transact(
      transfer(fromAccount, toAccount, 20),
      Person.name("John"),
      UseCase.name("Scheduled transfer"))
    
    // Query multiple Tx meta data molecules
    Account(fromAccount).balance
      .Tx(Person.name_("John"))
      .Tx(UseCase.name_("Scheduled transfer")).get.head === 80
    Account(toAccount).balance
      .Tx(Person.name_("John"))
      .Tx(UseCase.name_("Scheduled transfer")).get.head === 720
    txFnCall

    Tx function invocation

    txMolecules

    Optional tx meta data molecules

    returns

    TxReport with result of transaction

    Definition Classes
    TxMethods
  56. def transact(stmtss: Seq[Seq[Statement]]*)(implicit conn: Conn): TxReport

    Transact bundled transaction statements

    Supply transaction statements of one or more molecule actions to perform a single atomic transaction.

    Transact bundled transaction statements

    Supply transaction statements of one or more molecule actions to perform a single atomic transaction.

    transact(
      // retract entity
      e1.getRetractTx,
      // save new entity
      Ns.int(4).getSaveTx,
      // insert multiple new entities
      Ns.int.getInsertTx(List(5, 6)),
      // update entity
      Ns(e2).int(20).getUpdateTx
    )
    stmtss

    Statement's from multiple molecule operations

    conn

    Implicit Conn value in scope

    returns

    TxReport with result of transaction

    Definition Classes
    TxMethods
  57. macro def transactAsync(txFnCall: Seq[Seq[Statement]], txMolecules: MoleculeBase*): TxReport

    Asynchronously transact tx function invocation

    Macro that takes a tx function invocation itself as its argument.

    Asynchronously transact tx function invocation

    Macro that takes a tx function invocation itself as its argument. The tx function is analyzed by the macro and the necessary transaction preparations done at compile time.

    At runtime, the returned statements from the tx function is asynchronously transacted as one atomic transaction using Datomic's asynchronous API.

    Await.result(
      transactAsync(transfer(fromAccount, toAccount, 20)) map { txReport =>
        Account(fromAccount).balance.get.head === 80 // (could be asynchronous too)
        Account(toAccount).balance.get.head === 720
      },
      2.seconds
    )

    Additional transaction meta data can be added

    Await.result(
      transactAsync(
        transfer(fromAccount, toAccount, 20),
        Person.name("John"),
        UseCase.name("Scheduled transfer")) map { txReport =>
          Account(fromAccount).balance
          .Tx(Person.name_("John"))
          .Tx(UseCase.name_("Scheduled transfer"))
          .get.head === 80 // (could be asynchronous too)
      },
      2.seconds
    )
    txFnCall

    Tx function invocation

    txMolecules

    Optional tx meta data molecules

    returns

    Future with TxReport with result of transaction

    Definition Classes
    TxMethods
  58. def transactAsync(stmtss: Seq[Seq[Statement]]*)(implicit conn: Conn, ec: ExecutionContext): Future[TxReport]

    Asynchronously transact bundled transaction statements

    Asynchronously transact bundled transaction statements

    Supply transaction statements of one or more molecule actions to asynchronously transact a single atomic transaction.

    Await.result(
      transactAsync(
        e1.getRetractTx,
        Ns.int(4).getSaveTx,
        Ns.int.getInsertTx(List(5, 6)),
        Ns(e2).int(20).getUpdateTx
      ) map { bundleTx =>
        Ns.int.getAsync map { queryResult =>
          queryResult === List(3, 4, 5, 6, 20)
        }
      },
      2.seconds
    )
    stmtss

    Statement's from multiple molecule operations

    conn

    Implicit Conn value in scope

    returns

    Future with TxReport with result of transaction

    Definition Classes
    TxMethods
  59. def transactSchema(schema: SchemaTransaction, identifier: String, protocol: String = "mem"): Conn

    Transact schema from auto-generated schema transaction data.

    Transact schema from auto-generated schema transaction data.

    schema

    sbt-plugin auto-generated Transaction file path.to.schema.YourDomainSchema

    Definition Classes
    Datomic
  60. implicit final def tuple2Model[A, B](tpl: (A, B)): TermValue[(A, B)]

    Definition Classes
    LogicImplicits
  61. implicit final def uri2Model(v: URI): TermValue[URI]

    Definition Classes
    LogicImplicits
  62. implicit final def uriSet2Model(set: Set[URI]): TermValue[Set[URI]]

    Definition Classes
    LogicImplicits
  63. implicit final def uuid2Model(v: UUID): TermValue[UUID]

    Definition Classes
    LogicImplicits
  64. implicit final def uuidSet2Model(set: Set[UUID]): TermValue[Set[UUID]]

    Definition Classes
    LogicImplicits
  65. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  66. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  67. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @throws( ... )
  68. object ? extends expression.AttrExpressions.?
    Definition Classes
    core
  69. object avg extends core.avg
    Definition Classes
    core
  70. object count extends core.count
    Definition Classes
    core
  71. object countDistinct extends core.countDistinct
    Definition Classes
    core
  72. object distinct extends core.distinct
    Definition Classes
    core
  73. object max extends core.max
    Definition Classes
    core
  74. object median extends core.median
    Definition Classes
    core
  75. object min extends core.min
    Definition Classes
    core
  76. object rand extends core.rand
    Definition Classes
    core
  77. object sample extends core.sample
    Definition Classes
    core
  78. object stddev extends core.stddev
    Definition Classes
    core
  79. object sum extends core.sum
    Definition Classes
    core
  80. object unify extends core.unify
    Definition Classes
    core
  81. object variance extends core.variance
    Definition Classes
    core
  82. object Log extends Log_0 with FirstNS

    Log object to start Log molecule.

    Log object to start Log molecule.

    Definition Classes
    GenericLog
  83. object AEVT extends AEVT_0 with FirstNS

    AEVT Index object to start AEVT Index molecule.

    AEVT Index object to start AEVT Index molecule.

    Definition Classes
    GenericAEVT
  84. object AVET extends AVET_0 with FirstNS

    AVET Index object to start AVET Index molecule.

    AVET Index object to start AVET Index molecule.

    Definition Classes
    GenericAVET
  85. object EAVT extends EAVT_0 with FirstNS

    EAVT Index object to instantiate EAVT Index molecule.

    EAVT Index object to instantiate EAVT Index molecule.

    Definition Classes
    GenericEAVT
  86. object VAET extends VAET_0 with FirstNS

    VAET Index object to start VAET reverse Index molecule.

    VAET Index object to start VAET reverse Index molecule.

    Definition Classes
    GenericVAET
  87. object Schema extends Schema_0 with FirstNS

    Schema object to start Schema molecule.

    Schema object to start Schema molecule.

    Definition Classes
    GenericSchema

Inherited from Composite_In_2_Factory2

Inherited from Composite_In_1_Factory2

Inherited from Composite_Factory2

Inherited from Molecule_In_2_Factory2

Inherited from Molecule_In_1_Factory2

Inherited from Molecule_Factory2

Inherited from core

Inherited from GenericVAET

Inherited from GenericEAVT

Inherited from GenericAVET

Inherited from GenericAEVT

Inherited from GenericLog

Inherited from GenericSchema

Inherited from TxMethods

Inherited from EntityOps

Inherited from LogicImplicits

Inherited from AggregateKeywords

Inherited from AttrExpressions

Inherited from Datomic

Inherited from AnyRef

Inherited from Any

Database operations

Entity operations

Bundled transactions

Multiple molecule operations in one atomic transaction.

Transaction functions

Atomic transaction logic with access to tx database value.

Attribute markers

Markers applied to attributes that change the semantics of the attribute/molecule.

Expression implicits

Turns basic types into TermValue's that can be used in Expression

Aggregate keywords

Keywords applied to attributes that return aggregated value(s).

Number aggregation keywords

Keywords applied to number attributes that return aggregated value(s).

molecule

input1

input2

composite

composite1

composite2

Ungrouped