Struct owoof::projection::Projection

pub struct Projection<'a, V> { /* fields omitted */ }

A collection of datom-sets with constraints relating them.

This references attributes and entities by their handles/public representations.

Implementations

impl<'a, V> Projection<'a, V> where
    V: Debug + HasAffinity, 

pub fn from_patterns(patterns: &'a [Pattern<'_, V>]) -> Self

pub fn datomsets(&self) -> usize

pub fn variables(&self) -> &HashMap<&'a str, Location>

pub fn constraints(&self) -> &Vec<Constraint<'a, V>>

pub fn variable(&self, n: &str) -> Option<Location>

Return the first location (if any) where this variable was used.

pub fn var(&self, n: &str) -> Option<Location>

pub fn variable_locations(&self, n: &str) -> impl Iterator<Item = Location> + '_

As Projection::constrained_to but looks up the variable's location of first use.

Note, this doesn't search every spot the variable might have been used; we don't track that. It will only return locations constrainted the the location of the variable's first use.

This should be fine if you're using Projection::constrain_variable() or Projection::variable() to get a variable's location when building constraints, since those will always return the variable's location of first use.

pub fn constrained_to(
    &self,
    loc: Location
) -> impl Iterator<Item = Location> + '_

Find Locations with an equality constraint on this location.

pub fn add_datomset(&mut self) -> DatomSet

pub fn add_constraint(&mut self, c: Constraint<'a, V>)

This is needed to add non-equality constraints

pub fn constrain_variable(&mut self, variable: &'a str, location: Location)

Register a variable at some location. If it was registered before, constraint the existing variable to the given location.

Nothing happens if this receives the anonymous variable (the empty string). TODO this may never be what anybody wants at all ever...

pub fn constrain_field<I>(&mut self, location: Location, i: I) where
    I: Into<Concept<'a, V>>, 

pub fn add_patterns(&mut self, patterns: &'a [Pattern<'_, V>])

pub fn add_pattern<'p: 'a>(&mut self, pattern: &'p Pattern<'_, V>) -> DatomSet

Appends a datomset to the projection with Projection::add_datomset, constraining each entity-attribute-value to either a variable or a value based on the given Pattern.

pub fn select<'s, S>(&'s mut self, s: S) -> Selection<'s, 'a, V, S>

Select allows us to get an object we can pass to crate::Session::find that can resolve query results into a vector or maybe tuples I think too.

See the [owoof::projection] module documentation for an example.

pub fn entity_group<'p>(
    &'p mut self,
    var: &'a str
) -> Option<EntityGroup<'p, 'a, V>> where
    'a: 'p, 

This is part of representing a bunch of datomsets all constrained to the same entity. Suppose you've got ...

?birthday-person :person/birthday ?today
?birthday-person :person/name ?name
?birthday-person :person/age ?age

... using Projection::select we can ask for the values of specific locations and end up with a sequence or [?name ?age] for each ?birthday-person or something.

But using an EntityGroup allows us to construct an AttributeMap which implements crate::sql::ReadFromRow to produce a HashMap on attributes to values.

So instead of ending up with a sequence for each matching "object" we get a map. Which might be nice sometimes like if you want to serialize a self-describing JSON document.

See the [owoof::projection] module documentation for an example.

pub fn attribute_map<'p, I>(
    &mut self,
    top: &'a str,
    attrs: I
) -> AttributeMap<'p, V> where
    'a: 'p,
    I: IntoIterator<Item = &'a AttributeName<'a>>, 

short-hand for Projection::entity_group & EntityGroup::attribute_map.

Trait Implementations

impl<'a, V: Debug> Debug for Projection<'a, V>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a, V> Default for Projection<'a, V>

fn default() -> Self

Returns the "default value" for a type.