Molecule1.0.2 < Back

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.

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

molecule.core.expression.AttrExpressions

FulltextExpr

trait FulltextExpr[Ns, In] extends AnyRef

Expression methods of String attributes with fulltext search.

Source: AttrExpressions.scala

Linear Supertypes

AnyRef, Any

Known Subclasses

Fulltext, doc, doc$

Type Hierarchy

Ordering

Alphabetic
By Inheritance

Inherited

FulltextExpr
AnyRef
Any

Hide All
Show All

Visibility

Public
All

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
def clone(): AnyRef

Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws( ... ) @native()

def contains(words: qm): In with Attr

Mark as input molecule with String attribute word search.

Mark as input molecule with String attribute word search.

Fulltext searches are case-insensitive and only searches for whole words.

for {
  _ <- Phrase.id.txt.get.map(_ ==> List(
    (1, "The quick fox jumps"),
    (2, "Ten slow monkeys")
  ))

  // Mark as input molecule awaiting word(s) to search for
  phraseFinder = m(Phrase.id.txt_.contains(?))

  // Then we can apply words to the input molecule at runtime:

  _ <- phraseFinder("jumps").get.map(_ ==> List(1))

  // Only whole words matched
  _ <- phraseFinder("jump").get.map(_ ==> Nil)

  // Searches are case-insensitive
  _ <- phraseFinder("JuMpS").get.map(_ ==> List(1))

  // Empty spaces ignored
  _ <- phraseFinder("   jumps   ").get.map(_ ==> List(1))

  // Multiple search words have OR semantics
  _ <- phraseFinder("jumps", "slow").get.map(_ ==> List(1, 2))

  // Common words ignored
  _ <- phraseFinder("The").get.map(_ ==> Nil)
} yield ()

words: Search words
returns: Input molecule awaiting search word(s)

Note: Fulltext search is constrained by several defaults (which cannot be altered): searches are case insensitive, remove apostrophe or apostrophe and s sequences, and filter out the following common English stop words: "a", "an", "and", "are", "as", "at", "be", "but", "by", "for", "if", "in", "into", "is", "it", "no", "not", "of", "on", "or", "such", "that", "the", "their", "then", "there", "these", "they", "this", "to", "was", "will", "with"

def contains(word: String, moreWords: String*): Ns with Attr
Match words of String attribute.
Match words of String attribute.

Fulltext searches are case-insensitive and only searches for whole words.
```
for {
  _ <- Phrase.id.txt.get.map(_ ==> List(
    (1, "The quick fox jumps"),
    (2, "Ten slow monkeys")
  ))

  _ <- Phrase.id.txt_.contains("jumps").get.map(_ ==> List(1))

  // Only whole words matched
  _ <- Phrase.id.txt_.contains("jump").get.map(_ ==> Nil)

  // Searches are case-insensitive
  _ <- Phrase.id.txt_.contains("JuMpS").get.map(_ ==> List(1))

  // Empty spaces ignored
  _ <- Phrase.id.txt_.contains("   jumps   ").get.map(_ ==> List(1))

  // Multiple search words have OR semantics
  _ <- Phrase.id.txt_.contains("jumps", "slow").get.map(_ ==> List(1, 2))

  // Common words ignored
  _ <- Phrase.id.txt_.contains("The").get.map(_ ==> Nil)
} yield ()
```
word
Search word
moreWords
Optional additional search words
returns
Filtered molecule

Note
Fulltext search is constrained by several defaults (which cannot be altered): searches are case insensitive, remove apostrophe or apostrophe and s sequences, and filter out the following common English stop words: "a", "an", "and", "are", "as", "at", "be", "but", "by", "for", "if", "in", "into", "is", "it", "no", "not", "of", "on", "or", "such", "that", "the", "their", "then", "there", "these", "they", "this", "to", "was", "will", "with"
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
Annotations
@native()
def hashCode(): Int

Definition Classes
AnyRef → Any
Annotations
@native()
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
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()
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... ) @native()

Packages

FulltextExpr

trait FulltextExpr[Ns, In] extends AnyRef

Value Members

Inherited from AnyRef

Inherited from Any

Ungrouped

Packages

FulltextExpr 

trait FulltextExpr[Ns, In] extends AnyRef

Value Members

Inherited from AnyRef

Inherited from Any

Ungrouped

FulltextExpr