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 AttrExpr[Ns, T] extends AnyRef

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

Value Members

  1. def !=(values: Seq[T]): Ns with Attr

    Match attribute values different from applied Iterable of values.

    Match attribute values different from applied Iterable of values.

    for {
  _ <- Person.name.get.map(_ ==> List("Ben", "Liz", "Joe"))

  // Negate Iterable of values
  _ <- Person.name.!=(List("Ben", "Joe")).get.map(_ ==> List("Liz"))

  // same as
  _ <- Person.name.not(List("Ben", "Joe")).get.map(_ ==> List("Liz"))
} yield ()
    values

    Iterable of negated attribute values

    returns

    Filtered molecule

  2. def !=(value: T, moreValues: T*): Ns with Attr

    Match attribute values different from one or more applied values.

    Match attribute values different from one or more applied values.

    for {
  _ <- Person.name.get.map(_ ==> List("Ben", "Liz", "Joe"))

  // Negate one value
  _ <- Person.name.!=("Ben").get.map(_ ==> List("Liz", "Joe"))

  // Negate multiple values
  _ <- Person.name.!=("Ben", "Liz").get.map(_ ==> List("Joe"))

  // same as
  _ <- Person.name.not("Ben", "Liz").get.map(_ ==> List("Joe"))
} yield ()
    value

    Negated attribute value

    moreValues

    Optional additional negated attribute values

    returns

    Filtered molecule

  3. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. final def ##(): Int
    Definition Classes
    AnyRef → Any
  5. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  6. def apply(unifyer: unify_stable): Ns with Attr

    Mark tacit attribute to be unified in self-join.

    Mark tacit attribute to be unified in self-join.

    Attributes before Self are joined with attributes added after Self by values that can unify:

    Find 23-year olds liking the same beverage as 25-year olds (unifying by beverage):

    for {
  _ <- Person.name.age(23).Drinks.beverage._Person.Self // create self join
        .name.age(25).Drinks.beverage_(unify)           // unify by beverage
        .get.map(_ ==> List(
          ("Joe", 23, "Coffee", "Ben", 25),  // Joe (23) and Ben(25) both like coffee
          ("Liz", 23, "Coffee", "Ben", 25),  // Liz (23) and Ben(25) both like coffee
          ("Liz", 23, "Tea", "Ben", 25)      // Liz (23) and Ben(25) both like tea
        ))
} yield ()

    unify marker can only be applied to tacit attribute (with underscore).

    unifyer

    unify marker to unify self-join by this attribute values

    returns

    Self-join molecule

  7. def apply(values: Iterable[T], moreValues: Iterable[T]*): Ns with Attr

    Match one or more Iterables of attribute values.

    Match one or more Iterables of attribute values.

    Multiple Iterables are concatenated into one Iterable of values to be matched.

    Applying value(s) to an attribute has different semantics depending on what operation is performed:

    for {
  // Querying with `get` - Ben is 42
  _ <- Person.name_(Set("Ben")).age.get.map(_ ==> List(42))

  members = List("Ben", "Liz")
  associates = List("Don", "Ann")

  // OR-semantics when multiple values are queried
  _ <- Person.name_(members).age.get.map(_ ==> List(42, 37))
  // Multiple Iterables concatenated
  _ <- Person.name_(members, associates).age.get.map(_ ==> List(42, 37, 71, 28))

  // Single value in Iterable can be added when saving
  // (although easier to apply the value directly)
  _ <- Person.name(List("Joe")).save

  // Saving multiple new card-many attribute values (all old values are retracted).
  // (Saving multiple new values not allowed for card-one attributes)
  sports = Set("golf", "diving")
  _ <- Person.hobbies(sports).save

  // Replacing value when updating (old value is retracted).
  _ <- Person(benId).age(List(43)).update

  // Replacing multiple values for card-many attributes (all old values are retracted).
  // (Replacing multiple values not allowed for card-one attributes)
  _ <- Person(benId).hobbies(Seq("reading", "walking")).update

  // Multiple Iterables can be applied
  _ <- Person(benId).hobbies(Seq("reading", "walking"), Set("stamps")).update
} yield ()
    values

    Iterable of attribute values to be matched

    moreValues

    Optional additional Iterables of attribute values to be matched

    returns

    Filtered molecule

  8. def apply(value: T, moreValues: T*): Ns with Attr

    Match one or more attribute values.

    Match one or more attribute values.

    Applying value(s) to an attribute has different semantics depending on what operation is performed:

    for {
  // Querying with `get` - Ben is 42
  _ <- Person.name_("Ben").age.get.map(_ ==> List(42))

  // OR-semantics when multiple values are queried
  _ <- Person.name_("Ben", "Liz").age.get.map(_ ==> List(42, 37))

  // Saving new value (any old value is retracted)
  _ <- Person.name("Joe").save

  // Saving multiple new card-many attribute values (all old values are retracted).
  // (Saving multiple new values not allowed for card-one attributes)
  _ <- Person.hobbies("golf", "diving").save

  // Replacing value when updating (old value is retracted).
  _ <- Person(benId).age(43).update

  // Replacing multiple values for card-many attributes (all old values are retracted).
  // (Replacing multiple values not allowed for card-one attributes)
  _ <- Person(benId).hobbies("reading", "walking").update
} yield ()
    value

    Attribute values to be matched

    moreValues

    Optional additional attribute values to be matched

    returns

    Filtered molecule

  9. def apply(): Ns with Attr

    Apply empty value to retract datom in an update.

    Apply empty value to retract datom in an update.

    for {
  benId <- Person.name("Ben").age(42).save.map(_.eid)
  _ <- Person.name.age$.get.map(_ ==> List(("Ben", Some(42))))

  // Retract Ben's age
  _ <- Person(benId).age().update
  _ <- Person.name.age$.get.map(_ ==> List(("Ben", None)))
} yield ()

    For cardinality-many attributes, all values of the attribute are retracted.

  10. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  11. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native()
  12. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  13. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  14. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  15. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  16. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  17. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  18. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  19. def not(values: Iterable[T]): Ns with Attr

    Match attribute values different from applied Iterable of values.

    Match attribute values different from applied Iterable of values.

    for {
  _ <- Person.name.get.map(_ ==> List("Ben", "Liz", "Joe"))

  // Negate Iterable of values
  _ <- Person.name.not(List("Ben", "Joe")).get.map(_ ==> List("Liz"))

  // same as
  _ <- Person.name.!=(List("Ben", "Joe")).get.map(_ ==> List("Liz"))
} yield ()
    values

    Iterable of negated attribute values

    returns

    Filtered molecule

  20. def not(value: T, moreValues: T*): Ns with Attr

    Match attribute values different from one or more applied values.

    Match attribute values different from one or more applied values.

    for {
  _ <- Person.name.get.map(_ ==> List("Ben", "Liz", "Joe"))

  // Negate one value
  _ <- Person.name.not("Ben").get.map(_ ==> List("Liz", "Joe"))

  // Negate multiple values
  _ <- Person.name.not("Ben", "Liz").get.map(_ ==> List("Joe"))

  // same as
  _ <- Person.name.!=("Ben", "Liz").get.map(_ ==> List("Joe"))
} yield ()
    value

    Negated attribute value

    moreValues

    Optional additional negated attribute values

    returns

    Filtered molecule

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

Inherited from AnyRef

Inherited from Any

Ungrouped