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.

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.

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.

Definition Classes: core

molecule.core

data

package data

Data model DSL and API.

Source: package.scala

Linear Supertypes

AnyRef, Any

Ordering

Alphabetic
By Inheritance

Inherited

data
AnyRef
Any

Hide All
Show All

Visibility

Public
Protected

Type Members

trait SchemaTransaction extends AnyRef
Schema transaction interface for auto-generated schema transaction data.

Value Members

object model

Data Model DSL.

Data Model DSL.

Define a Domain Data Model in a data model file.

For small projects, the schema can be defined without partition definitions where all namespaces reside in a default tacit partition:

package path.to.your.project
import molecule.data.model._       // import data model DSL

@InOut(1, 8)                       // Set input/output arity
object SeattleDataModel {          // data model object

  trait Person {                   // Namespace
    val name = oneString.fulltext  // String attribute definition with fulltext search
    val age  = oneInt              // Int attribute definition
  }

  // Additional namespaces...
}

For larger projects, it is recommended to group namespaces in partitions:

package path.to.your.project
import molecule.data.model._

@InOut(3, 15)
object SeattleDataModel {

  object customer {
    trait Person {
      val name    = oneString.fulltext
      val age     = oneInt
      val address = one[Address]
      val bought  = many[products.Item]
    }
    trait Address {
      val street = oneString.fulltext
      val city   = oneInt
    }
    // ..more namespaces in the `customer` partition
  }

  object products {
    trait Item {
      val title   = oneString
      val inStock = oneInt
    }
    // ..more namespaces in the `products` partition
  }

  // Additional partitions...
}

Packages

data

package data

Type Members

Value Members

Inherited from AnyRef

Inherited from Any

Ungrouped

Packages

data

package data

Type Members

Value Members

Inherited from AnyRef

Inherited from Any

Ungrouped

data