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 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.map(_.head ==> 3)         // count of asserted `age` attribute values
Person.age(countDistinct).get.map(_.head ==> 3) // count of asserted distinct `age` attribute values
Person.age(max).get.map(_.head ==> 38)          // maximum `age` value (using `compare`)
Person.age(min).get.map(_.head ==> 5)           // maximum `age` value (using `compare`)
Person.age(rand).get.map(_.head ==> 25)         // single random `age` value
Person.age(sample).get.map(_.head ==> 27)       // single sample `age` value (when single value, same as random)

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

// Aggregates on number attributes
Person.age(sum).get.map(_.head ==> 50)                  // sum of all `age` numbers
Person.age(avg).get.map(_.head ==> 16.66666667)         // average of all `age` numbers
Person.age(median).get.map(_.head ==> 7)                // median of all `age` numbers
Person.age(stddev).get.map(_.head ==> 15.107025591499)  // standard deviation of all `age` numbers
Person.age(variance).get.map(_.head ==> 228.2222222222) // variance of all `age` numbers
    Definition Classes
    core
  • trait AttrExpressions extends AnyRef

    Attribute expression markers and methods.

    Attribute expression markers and methods.

    Person.age(42)                           // equality
Person.name.contains("John")             // fulltext search
Person.age.!=(42)                        // negation (or `not`)
Person.age.<(42)                         // comparison (< > <= >=)
Person.age().get                         // match non-asserted datoms (null) in query
Person(benId).age().update               // apply empty value to retract value(s) in updates
Person.hobbies.assert("golf")            // assert card-many value(s)
Person.hobbies.replace("golf", "diving") // replace card-many attribute value(s)
Person.hobbies.retract("golf")           // retract card-many attribute value(s)
Person.tags.k("en")                      // match values of map attributes by key
Person.name(?)                           // initiate input molecules awaiting input at runtime
Person.name(unify)                       // Unify attributes in self-joins
    Definition Classes
    expression
  • AttrExpr
  • FulltextExpr
  • ManyAttrExpr
  • ManyExpr
  • MapAttrExpr
  • OneExpr
  • OptionalExpr
  • ValueAttrExpr
  • qm
  • unify_stable

trait ManyAttrExpr[Ns, Add, OldNew, Rem] extends AnyRef

Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. ManyAttrExpr
  2. AnyRef
  3. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

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. def assert(values: Iterable[Add]): Ns with Attr

    Assert Iterable of card-many attribute values.

    Assert Iterable of card-many attribute values.

    for {
  _ <- Person.hobbies.get.map(_ ==> List(Set("golf", "diving")))

  // Assert/add values of Iterable
  _ <- Person(benId).hobbies.assert(Seq("stamps", "walking", "theater")).update

  _ <- Person.hobbies.get.map(_ ==> List(Set("golf", "diving", "stamps", "walking", "theater")))
} yield ()
    values

    Iterable of attribute values

    returns

    Molecule to be updated

  6. def assert(value: Add, moreValues: Add*): Ns with Attr

    Assert one or more card-many attribute values.

    Assert one or more card-many attribute values.

    for {
  _ <- Person.hobbies.get.map(_ ==> List(Set("golf", "diving")))

  // Assert/add value
  _ <- Person(benId).hobbies.assert("stamps").update

  // Assert multiple values
  _ <- Person(benId).hobbies.assert("walking", "theater").update

  _ <- Person.hobbies.get.map(_ ==> List(Set("golf", "diving", "stamps", "walking", "theater")))
} yield ()
    value

    New attribute value

    moreValues

    Optional additional new attribute values

    returns

    Molecule to be updated

  7. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native()
  8. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  9. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  10. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  11. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  12. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  13. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  14. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  15. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  16. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  17. def replace(oldNews: Iterable[OldNew]): Ns with Attr

    Replace Iterable of card-many attribute values.

    Replace Iterable of card-many attribute values.

    Retracts old value and asserts new value.

    for {
  _ <- Person.hobbies.get.map(_ ==> List(Set("golf", "diving")))

  // Replace values by applying Iterable of old/new value pairs
  _ <- Person(benId).hobbies.replace("theater" -> "concerts", "diving" -> "football").update

  _ <- Person.hobbies.get.map(_ ==> List(Set("concerts", "football")))
} yield ()
    oldNews

    Iterable of old/new attribute values. For map attributes it's key/value pairs.

    returns

    Molecule to be updated

  18. def replace(oldNew: OldNew, oldNews: OldNew*): Ns with Attr

    Replace one or more card-many attribute values.

    Replace one or more card-many attribute values.

    Retracts old value and asserts new value.

    for {
  _ <- Person.hobbies.get.map(_ ==> List(Set("golf", "diving")))

  // Replace value by applying old/new value pair
  _ <- Person(benId).hobbies.replace("golf" -> "theater").update

  // Replace multiple values by applying multiple old/new value pairs
  _ <- Person(benId).hobbies.replace("theater" -> "concerts", "diving" -> "football").update

  _ <- Person.hobbies.get.map(_ ==> List(Set("concerts", "football")))
} yield ()
    oldNew

    Pair of old/new value

    oldNews

    Optional additional pairs of old/new value

    returns

    Molecule to be updated

  19. def retract(values: Iterable[Rem]): Ns with Attr

    Retract Iterable of card-many attribute values.

    Retract Iterable of card-many attribute values.

    for {
  _ <- Person.hobbies.get.map(_ ==> List(Set("golf", "diving", "stamps", "walking", "theater")))

  // Retract multiple values
  _ <- Person(benId).hobbies.retract(List("walking", "theater")).update

  _ <- Person.hobbies.get.map(_ ==> List(Set("golf", "diving", "stamps")))
} yield ()
    values

    Iterable of attribute values to be retracted

    returns

    Molecule to be updated

  20. def retract(value: Rem, moreValues: Rem*): Ns with Attr

    Retract one or more card-many attribute values.

    Retract one or more card-many attribute values.

    for {
  _ <- Person.hobbies.get.map(_ ==> List(Set("golf", "diving", "stamps", "walking", "theater")))

  // Retract value
  _ <- Person(benId).hobbies.retract("theater").update

  // Retract multiple values
  _ <- Person(benId).hobbies.retract("stamps", "walking").update

  _ <- Person.hobbies.get.map(_ ==> List(Set("golf", "diving")))
} yield ()
    value

    Attribute value to be retracted

    moreValues

    Optional additional attribute values to be retracted

    returns

    Molecule to be updated

  21. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  22. def toString(): String
    Definition Classes
    AnyRef → Any
  23. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  24. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  25. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native()

Inherited from AnyRef

Inherited from Any

Ungrouped