Packages

  • package root

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

    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.

    Definition Classes
    root
  • package core
    Definition Classes
    molecule
  • package api
    Definition Classes
    core
  • package ast

    Internal Molecule ASTs.

    Internal Molecule ASTs.

    Definition Classes
    core
  • package composition

    Methods to build transaction, composite and nested molecules.

    Methods to build transaction, composite and nested molecules.

    Definition Classes
    core
  • package nested_0
  • package nested_1
  • package nested_2
  • package nested_3
  • CompositeInit_0
  • CompositeInit_1
  • CompositeInit_2
  • CompositeInit_3
  • Composite_0
  • Composite_1
  • Composite_2
  • Composite_3
  • Tx
  • Tx_
  • Tx_0
  • Tx_1
  • Tx_2
  • Tx_3
  • package data

    Data model DSL and API.

    Data model DSL and API.

    Definition Classes
    core
  • package dsl

    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 exceptions

    Exceptions thrown by Molecule.

    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 factory

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

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

    Definition Classes
    core
  • package generic
    Definition Classes
    core
  • package macros
    Definition Classes
    core
  • package ops
    Definition Classes
    core
  • package transform
    Definition Classes
    core
  • package util

    Internal database functions for Datomic.

    Internal database functions for Datomic.

    Definition Classes
    core
p

molecule.core

composition

package composition

Methods to build transaction, composite and nested molecules.

Source
package.scala
Linear Supertypes
AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. composition
  2. AnyRef
  3. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Package Members

  1. package nested_0
  2. package nested_1
  3. package nested_2
  4. package nested_3

Type Members

  1. trait Tx extends AnyRef

    Transaction meta data on molecule.

    Transaction meta data on molecule.

    Tx takes a transaction meta data molecule with attributes having the transaction id as their entity id.

    // Save molecule with transaction data
Person.name("Ben").Tx(MyMetaData.action("add member")).save.eid

// Query for data with transaction meta data - "which persons became members"
Person.name.Tx(MyMetaData.action_("add member")).get === List("Ben")
  2. trait Tx_[props] extends AnyRef

Value Members

  1. object CompositeInit_0

    Build composite molecule.

    Build composite molecule.

    Composite molecules model entities with attributes from different namespaces that are not necessarily related. Each group of attributes is modelled by a molecule and the "sub-molecules" are tied together with + methods to form a composite molecule.

    The attributes of the first sub-molecule are tied together in a tuple of its own before being merged with the tuple of attribute values of the second sub-molecule. If any of the sub-molecules are of arity-1, then no tuple is created:

    // Arity 1 + 1
m(Article.name + Tag.category).get === List(
  ("Battle of Waterloo", "History")
)

// Arity 1 + 2
m(Article.name + Tag.category.weight).get === List(
  ("Battle of Waterloo", ("History", 5))
)

// Arity 2 + 1
m(Article.name.author + Tag.category).get === List(
  (("Battle of Waterloo", "Ben Bridge"), "History")
)

// Arity 2 + 2
m(Article.name.author + Tag.category.weight).get === List(
  (("Battle of Waterloo", "Ben Bridge"), ("History", 5))
)

// Arity 3 + 2 etc...
m(Article.name.author.editor + Tag.category.weight).get === List(
  (("Battle of Waterloo", "Ben Bridge", "Joe Moe"), ("History", 5))
)
  2. object CompositeInit_1

    Build composite molecule from input molecule awaiting 1 input.

    Build composite molecule from input molecule awaiting 1 input.

    Composite molecules model entities with attributes from different namespaces that are not necessarily related. Each group of attributes is modelled by a molecule and the "sub-molecules" are tied together with + methods to form a composite molecule.

    The attributes of the first input sub-molecule awaiting 1 input are tied together in a tuple of its own before being merged with the tuple of attribute values of the second sub-molecule. If any of the sub-molecules are of arity-1, then no tuple is created:

    m(Article.name(?).author.editor + Tag.category.weight)
  .apply("Battle of Waterloo").get === List(
    (("Battle of Waterloo", "Ben Bridge", "Joe Moe"), ("History", 5))
  )
  3. object CompositeInit_2

    Build composite molecule from input molecule awaiting 2 inputs.

    Build composite molecule from input molecule awaiting 2 inputs.

    Composite molecules model entities with attributes from different namespaces that are not necessarily related. Each group of attributes is modelled by a molecule and the "sub-molecules" are tied together with + methods to form a composite molecule.

    The attributes of the first input sub-molecule awaiting 2 inputs are tied together in a tuple of its own before being merged with the tuple of attribute values of the second sub-molecule. If any of the sub-molecules are of arity-1, then no tuple is created:

    m(Article.name(?).author(?).editor + Tag.category.weight)
  .apply("Battle of Waterloo", "Ben Bridge").get === List(
    (("Battle of Waterloo", "Ben Bridge", "Joe Moe"), ("History", 5))
  )
  4. object CompositeInit_3

    Build composite molecule from input molecule awaiting 3 inputs.

    Build composite molecule from input molecule awaiting 3 inputs.

    Composite molecules model entities with attributes from different namespaces that are not necessarily related. Each group of attributes is modelled by a molecule and the "sub-molecules" are tied together with + methods to form a composite molecule.

    The attributes of the first input sub-molecule awaiting 3 inputs are tied together in a tuple of its own before being merged with the tuple of attribute values of the second sub-molecule. If any of the sub-molecules are of arity-1, then no tuple is created:

    m(Article.name(?).author(?).editor(?) + Tag.category.weight)
  .apply("Battle of Waterloo", "Ben Bridge", "Joe Moe").get === List(
    (("Battle of Waterloo", "Ben Bridge", "Joe Moe"), ("History", 5))
  )
  5. object Composite_0

    Add sub-molecule to composite molecule.

    Add sub-molecule to composite molecule.

    Composite molecules model entities with attributes from different namespaces that are not necessarily related. Each group of attributes is modelled by a molecule and these "sub-molecules" are tied together with + methods to form a composite molecule.

    + methods of this interface adds a new sub-molecule to the composite.

    //                                          | add sub-molecule
m(Article.name.author + Tag.category.weight + Publisher.name).get === List(
  (("Battle of Waterloo", "Ben Bridge"), ("History", 5), "Bestseller Publications Inc.")
)
  6. object Composite_1

    Add sub-molecule to composite input molecule awaiting 1 input.

    Add sub-molecule to composite input molecule awaiting 1 input.

    Composite molecules model entities with attributes from different namespaces that are not necessarily related. Each group of attributes is modelled by a molecule and the "sub-molecules" are tied together with + methods to form a composite molecule.

    + methods of this interface adds a new sub-molecule to the composite.

    //             | input composite               | add sub-molecule
m(Article.name(?).author + Tag.category.weight + Publisher.name)
  .apply("Battle of Waterloo").get === List(
    (("Battle of Waterloo", "Ben Bridge"), ("History", 5), "Bestseller Publications Inc.")
  )
  7. object Composite_2

    Add sub-molecule to composite input molecule awaiting 2 inputs.

    Add sub-molecule to composite input molecule awaiting 2 inputs.

    Composite molecules model entities with attributes from different namespaces that are not necessarily related. Each group of attributes is modelled by a molecule and the "sub-molecules" are tied together with + methods to form a composite molecule.

    + methods of this interface adds a new sub-molecule to the composite.

    //             | input composite                  | add sub-molecule
m(Article.name(?).author(?) + Tag.category.weight + Publisher.name)
  .apply("Battle of Waterloo", "Ben Bridge").get === List(
    (("Battle of Waterloo", "Ben Bridge"), ("History", 5), "Bestseller Publications Inc.")
  )
  8. object Composite_3

    Add sub-molecule to composite input molecule awaiting 3 inputs.

    Add sub-molecule to composite input molecule awaiting 3 inputs.

    Composite molecules model entities with attributes from different namespaces that are not necessarily related. Each group of attributes is modelled by a molecule and the "sub-molecules" are tied together with + methods to form a composite molecule.

    + methods of this interface adds a new sub-molecule to the composite.

    //             | input composite                     | add sub-molecule
m(Article.name(?).author(?) + Tag.category.weight(?) + Publisher.name)
  .apply("Battle of Waterloo", "Ben Bridge", 5).get === List(
    (("Battle of Waterloo", "Ben Bridge"), ("History", 5), "Bestseller Publications Inc.")
  )
  9. object Tx_0
  10. object Tx_1
  11. object Tx_2
  12. object Tx_3

Inherited from AnyRef

Inherited from Any

Ungrouped