Molecule 0.17.2 - molecule.boilerplate.attributes.ManyRefAttr

def !=(values: Seq[Long]): Ns with Attr

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

def !=(value: Long): Ns with Attr

Match attribute values different from applied value.

Person.name.get === List("Ben", "Liz", "Joe")

// Negate value
Person.name.!=("Ben").get === List("Liz", "Joe")

// same as
Person.name.not("Ben").get === List("Liz", "Joe")

value: Negated attribute value
returns: Filtered molecule

Definition Classes: AttrExpr

def !=(value: Long, value2: Long, moreValues: Long*): Ns with Attr

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

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

def apply(unifyer: api.core.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

def apply(values: Seq[Long], moreValues: Seq[Long]*): 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

def apply(value: Long, moreValues: Long*): 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

def apply(): Ns with Attr

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

final def asInstanceOf[T0]: T0

Definition Classes: Any

def assert(values: Iterable[Long]): Ns with Attr

Assert Iterable of card-many attribute values.

Person.hobbies.get === List(Set("golf", "diving"))

// Assert/add values of Iterable
Person(benId).hobbies.assert(Seq("stamps", "walking", "theater")).update

Person.hobbies.get === List(Set("golf", "diving", "stamps", "walking", "theater"))

values: Iterable of attribute values
returns: Molecule to be updated

Definition Classes: ManyAttrExpr

def assert(value: Long, moreValues: Long*): Ns with Attr

Assert one or more card-many attribute values.

Person.hobbies.get === List(Set("golf", "diving"))

// Assert/add value
Person(benId).hobbies.assert("stamps").update

// Assert multiple values
Person(benId).hobbies.assert("walking", "theater").update

Person.hobbies.get === List(Set("golf", "diving", "stamps", "walking", "theater"))

value: New attribute value
moreValues: Optional additional new attribute values
returns: Molecule to be updated

Definition Classes: ManyAttrExpr

def clone(): AnyRef

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

final def eq(arg0: AnyRef): Boolean

Definition Classes: AnyRef

def equals(arg0: Any): Boolean

Definition Classes: AnyRef → Any

def finalize(): Unit

Attributes: protected[java.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

def not(values: Seq[Long]): Ns with Attr

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

def not(value: Long, moreValues: Long*): Ns with Attr

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

final def notify(): Unit

Definition Classes: AnyRef
Annotations: @native()

final def notifyAll(): Unit

Definition Classes: AnyRef
Annotations: @native()

def replace(oldNews: Iterable[(Long, Long)]): Ns with Attr

Replace Iterable of card-many attribute values.

Replace Iterable of card-many attribute values.

Retracts old value and asserts new value.

Person.hobbies.get === List(Set("golf", "diving"))

// Replace values by applying Iterable of old/new value pairs
Person(benId).hobbies.replace("theater" -> "concerts", "diving" -> "football").update

Person.hobbies.get === List(Set("concerts", "football"))

oldNews: Iterable of old/new attribute values. For map attributes it's key/value pairs.
returns: Molecule to be updated

Definition Classes: ManyAttrExpr

def replace(oldNew: (Long, Long), oldNews: (Long, Long)*): Ns with Attr

Replace one or more card-many attribute values.

Replace one or more card-many attribute values.

Retracts old value and asserts new value.

Person.hobbies.get === List(Set("golf", "diving"))

// Replace value by applying old/new value pair
Person(benId).hobbies.replace("golf" -> "theater").update

// Replace multiple values by applying multiple old/new value pairs
Person(benId).hobbies.replace("theater" -> "concerts", "diving" -> "football").update

Person.hobbies.get === List(Set("concerts", "football"))

oldNew: Pair of old/new value
oldNews: Optional additional pairs of old/new value
returns: Molecule to be updated

Definition Classes: ManyAttrExpr

def retract(values: Iterable[Long]): Ns with Attr

Retract Iterable of card-many attribute values.

Person.hobbies.get === List(Set("golf", "diving", "stamps", "walking", "theater"))

// Retract multiple values
Person(benId).hobbies.retract(List("walking", "theater")).update

Person.hobbies.get === List(Set("golf", "diving", "stamps"))

values: Iterable of attribute values to be retracted
returns: Molecule to be updated

Definition Classes: ManyAttrExpr

def retract(value: Long, moreValues: Long*): Ns with Attr

Retract one or more card-many attribute values.

Person.hobbies.get === List(Set("golf", "diving", "stamps", "walking", "theater"))

// Retract value
Person(benId).hobbies.retract("theater").update

// Retract multiple values
Person(benId).hobbies.retract("stamps", "walking").update

Person.hobbies.get === List(Set("golf", "diving"))

value: Attribute value to be retracted
moreValues: Optional additional attribute values to be retracted
returns: Molecule to be updated

Definition Classes: ManyAttrExpr

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: @native() @throws( ... )

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.
generic		Interfaces to generic information about datoms and Datomic database.
input		Input molecules awaiting input.
macro		Internal macros generating molecule code from custom DSL molecule constructs.
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.

Packages

Sub-packages

ManyRefAttr

trait ManyRefAttr[Ns, In] extends api.core.ManyRefAttrExpr[Ns, In] with RefAttr[Ns]

Value Members

Inherited from RefAttr[Ns]

Inherited from Attr

Inherited from api.core.ManyRefAttrExpr[Ns, In]

Inherited from api.core.ManyAttrExpr[Ns, Long, (Long, Long), Long]

Inherited from api.core.AttrExpr[Ns, Long]

Inherited from AnyRef

Inherited from Any

Ungrouped