object in1_out2 extends core with Molecule_Factory2 with Molecule_In_1_Factory2 with Composite_Factory2 with Composite_In_1_Factory2
- Grouped
- Alphabetic
- By Inheritance
- in1_out2
- Composite_In_1_Factory2
- Composite_Factory2
- Molecule_In_1_Factory2
- Molecule_Factory2
- core
- GenericVAET
- GenericEAVT
- GenericAVET
- GenericAEVT
- GenericLog
- GenericSchema
- TxMethods
- EntityOps
- LogicImplicits
- AggregateKeywords
- AttrExpressions
- Datomic
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Type Members
- type ?? = expression.AttrExpressions.?
- Definition Classes
- AttrExpressions
- trait avg extends AnyRef
Average of attribute values.
Average of attribute values.
Applyavg
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
- trait count extends AnyRef
Count of attribute values.
Count of attribute values.
Applycount
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
- trait countDistinct extends AnyRef
Count of distinct attribute values.
Count of distinct attribute values.
ApplycountDistinct
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
- trait distinct extends AnyRef
Distinct attribute values.
Distinct attribute values.
Applydistinct
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
- trait max extends AnyRef
Maximum attribute value(s).
Maximum attribute value(s).
Applymax
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.
- trait maxs extends AnyRef
- Definition Classes
- AggregateKeywords
- trait median extends AnyRef
Median of attribute values.
Median of attribute values.
Applymedian
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 numberMatch.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
- trait min extends AnyRef
Minimum attribute value(s).
Minimum attribute value(s).
Applymin
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.
- trait mins extends AnyRef
- Definition Classes
- AggregateKeywords
- trait rand extends AnyRef
Random attribute value(s).
Random attribute value(s).
Applyrandom
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
- trait rands extends AnyRef
- Definition Classes
- AggregateKeywords
- trait sample extends AnyRef
Sample attribute value(s).
Sample attribute value(s).
Applysample
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.
- trait samples extends AnyRef
- Definition Classes
- AggregateKeywords
- trait stddev extends AnyRef
Variance of attribute values.
Variance of attribute values.
Applystddev
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
- trait sum extends AnyRef
Sum of attribute values.
Sum of attribute values.
Applysum
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
- trait variance extends AnyRef
Variance of attribute values.
Variance of attribute values.
Applyvariance
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
- 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.
- trait AttrExpr[Ns, T] extends AnyRef
Expression methods common for all attributes.
Expression methods common for all attributes.
- Definition Classes
- AttrExpressions
- 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
- 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
- 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
- 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
- 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
- trait OptionalExpr[Ns, T] extends AnyRef
Expression methods of optional attributes.
Expression methods of optional attributes.
- Definition Classes
- AttrExpressions
- trait ValueAttrExpr[Ns, In, T] extends AttrExpr[Ns, T]
Expression methods of value attributes.
Expression methods of value attributes.
- Definition Classes
- AttrExpressions
- trait unify extends AnyRef
Unify attribute value in self-join.
Unify attribute value in self-join.
Applyunify
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
- final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def ##(): Int
- Definition Classes
- AnyRef → Any
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- implicit final def bigDec2Model(v: BigDecimal): TermValue[BigDecimal]
- Definition Classes
- LogicImplicits
- implicit final def bigDecSet2Model(set: Set[BigDecimal]): TermValue[Set[BigDecimal]]
- Definition Classes
- LogicImplicits
- implicit final def bigInt2Model(v: BigInt): TermValue[BigInt]
- Definition Classes
- LogicImplicits
- implicit final def bigIntSet2Model(set: Set[BigInt]): TermValue[Set[BigInt]]
- Definition Classes
- LogicImplicits
- implicit final def boolean2Model(v: Boolean): TermValue[Boolean]
- Definition Classes
- LogicImplicits
- implicit final def booleanSet2Model(set: Set[Boolean]): TermValue[Set[Boolean]]
- Definition Classes
- LogicImplicits
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native()
- implicit final def date2Model(v: Date): TermValue[Date]
- Definition Classes
- LogicImplicits
- implicit final def dateSet2Model(set: Set[Date]): TermValue[Set[Date]]
- Definition Classes
- LogicImplicits
- 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
- 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
- def debugTransact(stmtss: Seq[Seq[Statement]]*)(implicit conn: Conn): Unit
Debug bundled transaction statements
Add transaction statements from one or more molecule actions todebugTransact
to see the bundled transaction statements.Debug bundled transaction statements
Add transaction statements from one or more molecule actions todebugTransact
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) ======================================================================== */
- Definition Classes
- TxMethods
- implicit final def double2Model(v: Double): TermValue[Double]
- Definition Classes
- LogicImplicits
- implicit final def doubleSet2Model(set: Set[Double]): TermValue[Set[Double]]
- Definition Classes
- LogicImplicits
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable])
- implicit final def float2Model(v: Float): TermValue[Float]
- Definition Classes
- LogicImplicits
- implicit final def floatSet2Model(set: Set[Float]): TermValue[Set[Float]]
- Definition Classes
- LogicImplicits
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- implicit final def int2Model(v: Int): TermValue[Int]
- Definition Classes
- LogicImplicits
- implicit final def intSet2Model(set: Set[Int]): TermValue[Set[Int]]
- Definition Classes
- LogicImplicits
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- 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
- implicit final def long2Model(v: Long): TermValue[Long]
- Definition Classes
- LogicImplicits
- implicit final def longSet2Model(set: Set[Long]): TermValue[Set[Long]]
- Definition Classes
- LogicImplicits
- 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 likePerson
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, likeget
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
- 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 likePerson
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, likeget
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
- 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 likePerson
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, likeget
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
- 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 likePerson
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, likeget
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
- 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 likePerson
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, likeget
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
- 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 likePerson
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, likeget
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
- 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 likePerson
from the example below. Once the molecule models the desired data structure we can call various actions on it, likeget
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
- 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 likePerson
from the example below. Once the molecule models the desired data structure we can call various actions on it, likeget
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
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- 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:- Edit schema definition file
sbt compile
to update boilerplate code in generated jars- 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
- Definition Classes
- Datomic
- 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
- Definition Classes
- Datomic
- See also
https://docs.datomic.com/on-prem/data-structure-literals.html
- 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") )
- 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") )
- implicit final def string2Model(v: String): TermValue[String]
- Definition Classes
- LogicImplicits
- implicit final def stringSet2Model(set: Set[String]): TermValue[Set[String]]
- Definition Classes
- LogicImplicits
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def toString(): String
- Definition Classes
- AnyRef → Any
- 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
- 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
- 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
- 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
- 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
- implicit final def tuple2Model[A, B](tpl: (A, B)): TermValue[(A, B)]
- Definition Classes
- LogicImplicits
- implicit final def uri2Model(v: URI): TermValue[URI]
- Definition Classes
- LogicImplicits
- implicit final def uriSet2Model(set: Set[URI]): TermValue[Set[URI]]
- Definition Classes
- LogicImplicits
- implicit final def uuid2Model(v: UUID): TermValue[UUID]
- Definition Classes
- LogicImplicits
- implicit final def uuidSet2Model(set: Set[UUID]): TermValue[Set[UUID]]
- Definition Classes
- LogicImplicits
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()
- object ? extends expression.AttrExpressions.?
- Definition Classes
- core
- object avg extends core.avg
- Definition Classes
- core
- object count extends core.count
- Definition Classes
- core
- object countDistinct extends core.countDistinct
- Definition Classes
- core
- object distinct extends core.distinct
- Definition Classes
- core
- object max extends core.max
- Definition Classes
- core
- object median extends core.median
- Definition Classes
- core
- object min extends core.min
- Definition Classes
- core
- object rand extends core.rand
- Definition Classes
- core
- object sample extends core.sample
- Definition Classes
- core
- object stddev extends core.stddev
- Definition Classes
- core
- object sum extends core.sum
- Definition Classes
- core
- object unify extends core.unify
- Definition Classes
- core
- object variance extends core.variance
- Definition Classes
- core
- object Log extends Log_0 with FirstNS
Log object to start Log molecule.
Log object to start Log molecule.
- Definition Classes
- GenericLog
- 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
- 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
- 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
- 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
- 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_1_Factory2
Inherited from Composite_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).
Documentation/API for the Molecule library - a meta DSL for the Datomic database.
Manual | scalamolecule.org | Github | Forum