Struct terminus_store::store::StoreLayer

pub struct StoreLayer { /* fields omitted */ }

A layer that keeps track of the store it came out of, allowing the creation of a layer builder on top of this layer.

This type of layer supports querying what was added and what was removed in this layer. This can not be done in general, because the layer that has been loaded may not be the layer that was originally built. This happens whenever a rollup is done. A rollup will create a new layer that bundles the changes of various layers. It allows for more efficient querying, but loses the ability to do these delta queries directly. In order to support them anyway, the StoreLayer will dynamically load in the relevant files to perform the requested addition or removal query method.

Implementations

impl StoreLayer

pub async fn open_write(&self) -> Result<StoreLayerBuilder>

Create a layer builder based on this layer.

pub async fn parent(&self) -> Result<Option<StoreLayer>>

Returns the parent of this layer, if any, or None if this layer has no parent.

pub async fn squash(&self) -> Result<StoreLayer>

Create a new base layer consisting of all triples in this layer, as well as all its ancestors.

It is a good idea to keep layer stacks small, meaning, to only have a handful of ancestors for a layer. The more layers there are, the longer queries take. Squash is one approach of accomplishing this. Rollup is another. Squash is the better option if you do not care for history, as it throws away all data that you no longer need.

pub async fn rollup(&self) -> Result<()>

Create a new rollup layer which rolls up all triples in this layer, as well as all its ancestors.

It is a good idea to keep layer stacks small, meaning, to only have a handful of ancestors for a layer. The more layers there are, the longer queries take. Rollup is one approach of accomplishing this. Squash is another. Rollup is the better option if you need to retain history.

pub async fn rollup_upto(&self, upto: &StoreLayer) -> Result<()>

Create a new rollup layer which rolls up all triples in this layer, as well as all ancestors up to (but not including) the given ancestor.

It is a good idea to keep layer stacks small, meaning, to only have a handful of ancestors for a layer. The more layers there are, the longer queries take. Rollup is one approach of accomplishing this. Squash is another. Rollup is the better option if you need to retain history.

pub fn triple_addition_exists(
    &self,
    subject: u64,
    predicate: u64,
    object: u64
) -> Pin<Box<dyn Future<Output = Result<bool>> + Send>>

Returns a future that yields true if this triple has been added in this layer, or false if it doesn’t.

Since this operation will involve io when this layer is a rollup layer, io errors may occur.

pub fn triple_removal_exists(
    &self,
    subject: u64,
    predicate: u64,
    object: u64
) -> Pin<Box<dyn Future<Output = Result<bool>> + Send>>

Returns a future that yields true if this triple has been removed in this layer, or false if it doesn’t.

Since this operation will involve io when this layer is a rollup layer, io errors may occur.

pub fn triple_additions(
    &self
) -> Pin<Box<dyn Future<Output = Result<Box<dyn Iterator<Item = IdTriple> + Send>>> + Send>>

Returns a future that yields an iterator over all layer additions.

Since this operation will involve io when this layer is a rollup layer, io errors may occur.

pub fn triple_removals(
    &self
) -> Pin<Box<dyn Future<Output = Result<Box<dyn Iterator<Item = IdTriple> + Send>>> + Send>>

Returns a future that yields an iterator over all layer removals.

Since this operation will involve io when this layer is a rollup layer, io errors may occur.

pub fn triple_additions_s(
    &self,
    subject: u64
) -> Pin<Box<dyn Future<Output = Result<Box<dyn Iterator<Item = IdTriple> + Send>>> + Send>>

Returns a future that yields an iterator over all layer additions that share a particular subject.

Since this operation will involve io when this layer is a rollup layer, io errors may occur.

pub fn triple_removals_s(
    &self,
    subject: u64
) -> Pin<Box<dyn Future<Output = Result<Box<dyn Iterator<Item = IdTriple> + Send>>> + Send>>

Returns a future that yields an iterator over all layer removals that share a particular subject.

Since this operation will involve io when this layer is a rollup layer, io errors may occur.

pub fn triple_additions_sp(
    &self,
    subject: u64,
    predicate: u64
) -> Pin<Box<dyn Future<Output = Result<Box<dyn Iterator<Item = IdTriple> + Send>>> + Send>>

Returns a future that yields an iterator over all layer additions that share a particular subject and predicate.

Since this operation will involve io when this layer is a rollup layer, io errors may occur.

pub fn triple_removals_sp(
    &self,
    subject: u64,
    predicate: u64
) -> Pin<Box<dyn Future<Output = Result<Box<dyn Iterator<Item = IdTriple> + Send>>> + Send>>

Returns a future that yields an iterator over all layer removals that share a particular subject and predicate.

Since this operation will involve io when this layer is a rollup layer, io errors may occur.

pub fn triple_additions_p(
    &self,
    predicate: u64
) -> Pin<Box<dyn Future<Output = Result<Box<dyn Iterator<Item = IdTriple> + Send>>> + Send>>

Returns a future that yields an iterator over all layer additions that share a particular predicate.

Since this operation will involve io when this layer is a rollup layer, io errors may occur.

pub fn triple_removals_p(
    &self,
    predicate: u64
) -> Pin<Box<dyn Future<Output = Result<Box<dyn Iterator<Item = IdTriple> + Send>>> + Send>>

Returns a future that yields an iterator over all layer removals that share a particular predicate.

Since this operation will involve io when this layer is a rollup layer, io errors may occur.

pub fn triple_additions_o(
    &self,
    object: u64
) -> Pin<Box<dyn Future<Output = Result<Box<dyn Iterator<Item = IdTriple> + Send>>> + Send>>

Returns a future that yields an iterator over all layer additions that share a particular object.

Since this operation will involve io when this layer is a rollup layer, io errors may occur.

pub fn triple_removals_o(
    &self,
    object: u64
) -> Pin<Box<dyn Future<Output = Result<Box<dyn Iterator<Item = IdTriple> + Send>>> + Send>>

Returns a future that yields an iterator over all layer removals that share a particular object.

Since this operation will involve io when this layer is a rollup layer, io errors may occur.

pub fn triple_layer_addition_count(
    &self
) -> Pin<Box<dyn Future<Output = Result<usize>> + Send>>

Returns a future that yields the amount of triples that this layer adds.

Since this operation will involve io when this layer is a rollup layer, io errors may occur.

pub fn triple_layer_removal_count(
    &self
) -> Pin<Box<dyn Future<Output = Result<usize>> + Send>>

Returns a future that yields the amount of triples that this layer removes.

Since this operation will involve io when this layer is a rollup layer, io errors may occur.

pub fn retrieve_layer_stack_names(
    &self
) -> Pin<Box<dyn Future<Output = Result<Vec<[u32; 5]>>> + Send>>

Returns a future that yields a vector of layer stack names describing the history of this layer, starting from the base layer up to and including the name of this layer itself.

Trait Implementations

impl Clone for StoreLayer

fn clone(&self) -> StoreLayer

Returns a copy of the value.

pub fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Layer for StoreLayer

fn name(&self) -> [u32; 5]

The name of this layer.

fn parent_name(&self) -> Option<[u32; 5]>

fn node_and_value_count(&self) -> usize

The amount of nodes and values known to this layer. This also counts entries in the parent.

fn predicate_count(&self) -> usize

The amount of predicates known to this layer. This also counts entries in the parent.

fn subject_id(&self, subject: &str) -> Option<u64>

The numerical id of a subject, or None if the subject cannot be found.

fn predicate_id(&self, predicate: &str) -> Option<u64>

The numerical id of a predicate, or None if the predicate cannot be found.

fn object_node_id(&self, object: &str) -> Option<u64>

The numerical id of a node object, or None if the node object cannot be found.

fn object_value_id(&self, object: &str) -> Option<u64>

The numerical id of a value object, or None if the value object cannot be found.

fn id_subject(&self, id: u64) -> Option<String>

The subject corresponding to a numerical id, or None if it cannot be found.

fn id_predicate(&self, id: u64) -> Option<String>

The predicate corresponding to a numerical id, or None if it cannot be found.

fn id_object(&self, id: u64) -> Option<ObjectType>

The object corresponding to a numerical id, or None if it cannot be found.

fn triple_exists(&self, subject: u64, predicate: u64, object: u64) -> bool

Returns true if the given triple exists, and false otherwise.

fn triples(&self) -> Box<dyn Iterator<Item = IdTriple> + Send>

Iterator over all triples known to this layer.

fn triples_s(&self, subject: u64) -> Box<dyn Iterator<Item = IdTriple> + Send>

fn triples_sp(
    &self,
    subject: u64,
    predicate: u64
) -> Box<dyn Iterator<Item = IdTriple> + Send>

fn triples_p(&self, predicate: u64) -> Box<dyn Iterator<Item = IdTriple> + Send>

fn triples_o(&self, object: u64) -> Box<dyn Iterator<Item = IdTriple> + Send>

fn clone_boxed(&self) -> Box<dyn Layer>

Return a clone of this layer in a box.

fn triple_addition_count(&self) -> usize

Returns the total amount of triple additions in this layer and all its parents.

fn triple_removal_count(&self) -> usize

Returns the total amount of triple removals in this layer and all its parents.

fn all_counts(&self) -> LayerCounts

Create a struct with all the counts

fn id_triple_exists(&self, triple: IdTriple) -> bool

Returns true if the given triple exists, and false otherwise.

fn string_triple_exists(&self, triple: &StringTriple) -> bool

Returns true if the given triple exists, and false otherwise.

fn string_triple_to_id(&self, triple: &StringTriple) -> Option<IdTriple>

Convert a StringTriple to an IdTriple, returning None if any of the strings in the triple could not be resolved.

fn string_triple_to_partially_resolved(
    &self,
    triple: StringTriple
) -> PartiallyResolvedTriple

Convert all known strings in the given string triple to ids.

fn id_triple_to_string(&self, triple: &IdTriple) -> Option<StringTriple>

Convert an id triple to the corresponding string version, returning None if any of those ids could not be converted.

fn triple_count(&self) -> usize

Returns the total amount of triples in this layer and all its parents.