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 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
    molecule
    See also

    Manual: expressions | aggregates | input molecules

    Tests: expressions

  • 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
    See also

    Manual: expressions, aggregates, input molecules, self-join | Tests: expressions, input1, input2, input3

  • ?
  • AttrExpr
  • FulltextExpr
  • ManyAttrExpr
  • ManyExpr
  • MapAttrExpr
  • OneExpr
  • OptionalExpr
  • ValueAttrExpr
  • unify

trait OneExpr[Ns, In, T] extends ValueAttrExpr[Ns, In, T]

Expression methods of card-one attributes.

Source
AttrExpressions.scala
Linear Supertypes
ValueAttrExpr[Ns, In, T], AttrExpr[Ns, T], AnyRef, Any
Type Hierarchy
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. OneExpr
  2. ValueAttrExpr
  3. AttrExpr
  4. AnyRef
  5. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Value Members

  1. def !=(value: ??): In with Attr

    Mark molecule as input molecule awaiting attribute negation value(s).

    Mark molecule as input molecule awaiting attribute negation value(s).

    Person.name.age.get === List(("Ben", 42), ("Liz", 37))
    
    // Create input molecule at compile time by applying `?` marker to attribute
    val ageOfPersonsOtherThan = m(Person.name_.!=(?).age)
    
    // Apply `name` attribute value at runtime to get ages of all other than Ben
    ageOfPersonsOtherThan("Ben").get === List(37) // Liz' age
    value

    Input marker ? for negation value

    returns

    Input molecule

    Definition Classes
    ValueAttrExpr
  2. 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.

    Person.name.get === List("Ben", "Liz", "Joe")
    
    // Negate Iterable of values
    Person.name.!=(List("Ben", "Joe")).get === List("Liz")
    
    // same as
    Person.name.not(List("Ben", "Joe")).get === List("Liz")
    values

    Iterable of negated attribute values

    returns

    Filtered molecule

    Definition Classes
    AttrExpr
  3. 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.

    Person.name.get === List("Ben", "Liz", "Joe")
    
    // Negate one value
    Person.name.!=("Ben").get === List("Liz", "Joe")
    
    // Negate multiple values
    Person.name.!=("Ben", "Liz").get === List("Joe")
    
    // same as
    Person.name.not("Ben", "Liz").get === List("Joe")
    value

    Negated attribute value

    moreValues

    Optional additional negated attribute values

    returns

    Filtered molecule

    Definition Classes
    AttrExpr
  4. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  5. final def ##: Int
    Definition Classes
    AnyRef → Any
  6. def <(upper: ??): In with Attr

    Mark molecule as input molecule awaiting attribute upper value.

    Mark molecule as input molecule awaiting attribute upper value.

    Person.name.age.get === List(("Liz", 37), ("Ben", 42), ("Don", 71))
    
    // Create input molecule at compile time by applying `?` marker to attribute
    val personsUnder = m(Person.name.age_.<(?))
    
    // Apply upper value at runtime to get names of all under 42
    personsUnder(42).get === List("Liz")
    upper

    Input marker ? for upper value

    returns

    Input molecule

    Definition Classes
    ValueAttrExpr
  7. def <(upper: T): Ns with Attr

    Match attribute values less than upper value.

    Match attribute values less than upper value.

    Person.age.get === List(5, 12, 28)
    Person.age.<(12).get === List(5)
    upper

    Upper value

    returns

    Molecule

    Definition Classes
    ValueAttrExpr
  8. def <=(upper: ??): In with Attr

    Mark molecule as input molecule awaiting attribute upper value.

    Mark molecule as input molecule awaiting attribute upper value.

    Person.name.age.get === List(("Liz", 37), ("Ben", 42), ("Don", 71))
    
    // Create input molecule at compile time by applying `?` marker to attribute
    val personsUnderOrExactly = m(Person.name.age_.<=(?))
    
    // Apply upper value at runtime to get names of all under or exactly 42
    personsUnderOrExactly(42).get === List("Liz", "Ben")
    upper

    Input marker ? for upper value

    returns

    Input molecule

    Definition Classes
    ValueAttrExpr
  9. def <=(upper: T): Ns with Attr

    Match attribute values less than or equal to upper value.

    Match attribute values less than or equal to upper value.

    Person.age.get === List(5, 12, 28)
    Person.age.<=(12).get === List(5, 12)
    upper

    Upper value

    returns

    Molecule

    Definition Classes
    ValueAttrExpr
  10. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  11. def >(lower: ??): In with Attr

    Mark molecule as input molecule awaiting attribute lower value.

    Mark molecule as input molecule awaiting attribute lower value.

    Person.name.age.get === List(("Liz", 37), ("Ben", 42), ("Don", 71))
    
    // Create input molecule at compile time by applying `?` marker to attribute
    val personsOver = m(Person.name.age_.>(?))
    
    // Apply lower value at runtime to get names of all over 42
    personsOver(42).get === List("Don")
    lower

    Input marker ? for lower value

    returns

    Input molecule

    Definition Classes
    ValueAttrExpr
  12. def >(lower: T): Ns with Attr

    Match attribute values bigger than lower value

    Match attribute values bigger than lower value

    Person.age.get === List(5, 12, 28)
    Person.age.>(12).get === List(28)
    lower

    Lower value

    returns

    Molecule

    Definition Classes
    ValueAttrExpr
  13. def >=(lower: ??): In with Attr

    Mark molecule as input molecule awaiting attribute lower value.

    Mark molecule as input molecule awaiting attribute lower value.

    Person.name.age.get === List(("Liz", 37), ("Ben", 42), ("Don", 71))
    
    // Create input molecule at compile time by applying `?` marker to attribute
    val personsOverOrExactly = m(Person.name.age_.>=(?))
    
    // Apply lower value at runtime to get names of all over or exactly 42
    personsOverOrExactly(42).get === List("Ben", "Don")
    lower

    Input marker ? for lower value

    returns

    Input molecule

    Definition Classes
    ValueAttrExpr
  14. def >=(lower: T): Ns with Attr

    Match attribute values bigger than or equal to lower value.

    Match attribute values bigger than or equal to lower value.

    Person.age.get === List(5, 12, 28)
    Person.age.>=(12).get === List(12, 28)
    lower

    Lower value

    returns

    Molecule

    Definition Classes
    ValueAttrExpr
  15. def apply(expr3: Exp3[T, T, T]): Ns with Attr

    Expression AST for building OR/AND expressions.

    Expression AST for building OR/AND expressions.

    Person.name.age.hobbies.get === List(
      ("Liz", 37, Set("golf", "diving")),
      ("Ben", 42, Set("golf", "diving", "reading")),
      ("Joe", 42, Set("golf", "reading"))
    )
    
    // Apply two AND expression for card-many attributes
    Person.name.hobbies_("golf" and "diving" and "reading").get === List("Ben")

    With input molecules we can apply logic to multiple attributes at once.

    Person.name.age.noOfCars.noOfKids.get === List(
      ("Joe", 42, 1, 2),
      ("Ben", 42, 1, 1),
      ("Liz", 37, 2, 3)
    )
    // Apply AND-triples to OR expression:
    val persons = m(Person.name.age_(?).noOfCars(?).noOfKids_(?))
    persons((42 and 1 and 1) or (37 and 2 and 3)).get === List("Ben", "Liz")
    expr3

    OR/AND expression

    returns

    Molecule

    Definition Classes
    ValueAttrExpr
  16. def apply(expr2: Exp2[T, T]): Ns with Attr

    Filter attribute values with logical expression.

    Filter attribute values with logical expression.

    Person.name.age.hobbies.get === List(
      ("Joe", 42, Set("golf", "reading")),
      ("Ben", 42, Set("golf", "diving", "reading")),
      ("Liz", 37, Set("golf", "diving"))
    )
    
    // Apply AND expression for card-many attributes
    Person.name.hobbies_("golf" and "diving").get === List("Ben", "Liz")
    
    // Given an input molecule awaiting 2 inputs, we can apply AND-pairs to OR expression:
    val persons = m(Person.name_(?).age(?))
    persons(("Ben" and 42) or ("Liz" and 37)).get === List(42, 37)
    expr2

    OR/AND expression

    returns

    Molecule

    Definition Classes
    ValueAttrExpr
  17. def apply(expr1: Exp1[T]): Ns with Attr

    Filter attribute values with logical expression.

    Filter attribute values with logical expression.

    Person.name.age.get === List(
      ("Liz", 37),
      ("Ben", 42),
      ("Don", 71)
    )
    
    // Apply OR expression
    // Match all entities with `name` attribute having value "Liz" or "Ben"
    Person.name_("Liz" or "Ben").age.get === List(37, 42)
    expr1

    OR expression

    returns

    Molecule

    Definition Classes
    ValueAttrExpr
  18. def apply(value: ??): In with Attr

    Mark molecule as input molecule awaiting attribute value(s) to be matched.

    Mark molecule as input molecule awaiting attribute value(s) to be matched.

    Person.name.age.get === List(("Ben", 42), ("Liz", 37))
    
    // Create input molecule at compile time by applying `?` marker to attribute
    val ageOfPerson = m(Person.name_(?).age)
    
    // Apply `name` attribute value at runtime to get age
    ageOfPerson("Ben").get === List(42)
    value

    Input marker ? for equality match

    returns

    Input molecule

    Definition Classes
    ValueAttrExpr
  19. def apply(unifyer: unify): 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):

    Person.name.age(23).Drinks.beverage._Person.Self // create self join
          .name.age(25).Drinks.beverage_(unify)      // unify by beverage
          .get === 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
          )

    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

    Definition Classes
    AttrExpr
  20. def apply(values: Seq[T], moreValues: Seq[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:

    // Querying with `get` - Ben is 42
    Person.name_(Set("Ben")).age.get === List(42)
    
    val members = List("Ben", "Liz")
    val associates = List("Don", "Ann")
    
    // OR-semantics when multiple values are queried
    Person.name_(members).age.get === List(42, 37)
    // Multiple Iterables concatenated
    Person.name_(members, associates).age.get === 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)
    val 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
    values

    Iterable of attribute values to be matched

    moreValues

    Optional additional Iterables of attribute values to be matched

    returns

    Filtered molecule

    Definition Classes
    AttrExpr
  21. 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:

    // Querying with `get` - Ben is 42
    Person.name_("Ben").age.get === List(42)
    
    // OR-semantics when multiple values are queried
    Person.name_("Ben", "Liz").age.get === 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
    value

    Attribute values to be matched

    moreValues

    Optional additional attribute values to be matched

    returns

    Filtered molecule

    Definition Classes
    AttrExpr
  22. def apply(): Ns with Attr

    Apply empty value to retract datom in an update.

    Apply empty value to retract datom in an update.

    val benId = Person.name("Ben").age(42).save.eid
    Person.name.age$ === List(("Ben", Some(42)))
    
    // Retract Ben's age
    Person(benId).age().update
    Person.name.age$ === List(("Ben", None))

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

    Definition Classes
    AttrExpr
  23. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  24. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.CloneNotSupportedException]) @native()
  25. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  26. def equals(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef → Any
  27. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.Throwable])
  28. final def getClass(): Class[_ <: AnyRef]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  29. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  30. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  31. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  32. def not(value: ??): In with Attr

    Mark molecule as input molecule awaiting attribute negation value(s).

    Mark molecule as input molecule awaiting attribute negation value(s).

    Person.name.age.get === List(("Ben", 42), ("Liz", 37))
    
    // Create input molecule at compile time by applying `?` marker to attribute
    val ageOfPersonsOtherThan = m(Person.name_.not(?).age)
    
    // Apply `name` attribute value at runtime to get ages of all other than Ben
    ageOfPersonsOtherThan("Ben").get === List(37) // Liz' age
    value

    Input marker ? for negation value

    returns

    Input molecule

    Definition Classes
    ValueAttrExpr
  33. def not(values: Seq[T]): Ns with Attr

    Match attribute values different from applied Iterable of values.

    Match attribute values different from applied Iterable of values.

    Person.name.get === List("Ben", "Liz", "Joe")
    
    // Negate Iterable of values
    Person.name.not(List("Ben", "Joe")).get === List("Liz")
    
    // same as
    Person.name.!=(List("Ben", "Joe")).get === List("Liz")
    values

    Iterable of negated attribute values

    returns

    Filtered molecule

    Definition Classes
    AttrExpr
  34. 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.

    Person.name.get === List("Ben", "Liz", "Joe")
    
    // Negate one value
    Person.name.not("Ben").get === List("Liz", "Joe")
    
    // Negate multiple values
    Person.name.not("Ben", "Liz").get === List("Joe")
    
    // same as
    Person.name.!=("Ben", "Liz").get === List("Joe")
    value

    Negated attribute value

    moreValues

    Optional additional negated attribute values

    returns

    Filtered molecule

    Definition Classes
    AttrExpr
  35. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  36. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  37. final def synchronized[T0](arg0: => T0): T0
    Definition Classes
    AnyRef
  38. def toString(): String
    Definition Classes
    AnyRef → Any
  39. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  40. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  41. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException]) @native()

Inherited from ValueAttrExpr[Ns, In, T]

Inherited from AttrExpr[Ns, T]

Inherited from AnyRef

Inherited from Any

Ungrouped