Home

Write powerful Datomic queries in Scala with the words of your domain:

Type-inferred Queries

Build query molecules with your domain attributes

val persons: Iterable[(String, Int)] = Person.name.age.get

“Name and age of Persons”

Relationships

Pick attributes across namespaces

Person.name.age.Address.street.Country.name.get

“Name, age, street and country of residence”

Conditional values

Apply required values for certain attributes

Person.name("Johnson").age.Address.City.name("New York").get

“Age of Johnsons in New York” - name, age and city returned

Control output

Add an underscore to omit an attribute from the result set:

Person.name_("Johnson").age.Address.City.name_("New York").get

“Age of Johnsons in New York” - only ages returned

Logic and ranges

Apply logical options and ranges

Person.name("Dean" or "Johnson").age.<(25).Address.Country.iso2("US").get

“Young Dean and Johnsons in the US”

Insert multi-level data

Insert data for multiple namespace levels in one go:

Person.name("Johnson").age(35).Address.street("5th").City.name("New York").add

“Add a 35-year-old Johnson living on 5th street in New York”

Upsert data

Add new facts

Person(johnsonId).Address.street("Broadway").update

“Johnson now lives on Broadway”

More..

Molecule is a Scala meta-DSL that translates “molecules” of your domain attributes to typed Datalog queries for Datomic - the database of immutable facts.

Videos

Marc Grue presents his Molecule library in 4 parts:

Datomic data model
Introduction to the data model of Datomic that Molecule is based on.
Building a DSL with Scala macros
A look behind the scenes of how Molecule is build.
Molecule tour
A walk through of Molecule features.
Molecule domain modelling
Using Molecule in your domain modelling.

More info

How does it work?

Define schema (once)

Our domain could have a Person with attributes name and age having a relationship to an Address so we define a schema for our domain:

trait Person {
  val name    = oneString
  val age     = oneInt
  val address = one[Address]
}
trait Address {
  val street = oneString
}

Compile (once)

> cd yourProjectRoot
> sbt compile

Molecule uses our schema as a template to generate some boilerplate code so that we can compose intuitive and powerful query molecules. This step is only needed when we create or change our schema.

Use molecules

Now we can insert data with molecules:

Person.name.age.Address.street insert List(
  ("Lisa", 20, "Broadway"),
  ("John", 22, "Fifth Avenue")
)

And retrieve data:

Person.name.age.Address.street.get === List(
  ("Lisa", 20, "Broadway"),
  ("John", 22, "Fifth Avenue")
)

The implicit macros insert and get turns our molecules into type-safe Datalog inserts and queries at compile time. So there's no runtime overhead.

Try demo

git clone https://github.com/scalamolecule/molecule-demo.git
cd molecule-demo
sbt compile
Open in your IDE
Run app - and build new molecules…

Get started…

Introduction to Datomic/Molecule
Setup Database: initiate a Datomic database and create a database schema with Molecule
Populate Database: populate a Datomic database with Molecule
Molecule Seattle tutorial examples of using Molecule (based on the Datomic Seattle tutorial)