Struct terminus_store::store::sync::SyncStoreLayer

pub struct SyncStoreLayer { /* 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 SyncStoreLayer will dynamically load in the relevant files to perform the requested addition or removal query method.

Implementations

impl SyncStoreLayer

pub fn open_write(&self) -> Result<SyncStoreLayerBuilder, Error>

Create a layer builder based on this layer.

pub fn parent(&self) -> Result<Option<SyncStoreLayer>, Error>

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

pub fn squash(&self) -> Result<SyncStoreLayer, Error>

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 fn rollup(&self) -> Result<(), Error>

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 fn rollup_upto(&self, upto: &SyncStoreLayer) -> Result<(), Error>

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 imprecise_rollup_upto(&self, upto: &SyncStoreLayer) -> Result<(), Error>

Like rollup_upto, rolls up upto the given layer. However, if this layer is a rollup layer, this will roll up upto that rollup.

pub fn triple_addition_exists(
    &self,
    subject: u64,
    predicate: u64,
    object: u64
) -> Result<bool>

Returns 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
) -> Result<bool>

Returns 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
) -> Result<Box<dyn Iterator<Item = IdTriple> + Send>>

Returns 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
) -> Result<Box<dyn Iterator<Item = IdTriple> + Send>>

Returns 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
) -> Result<Box<dyn Iterator<Item = IdTriple> + Send>>

Returns 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
) -> Result<Box<dyn Iterator<Item = IdTriple> + Send>>

Returns 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
) -> Result<Box<dyn Iterator<Item = IdTriple> + Send>>

Returns 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
) -> Result<Box<dyn Iterator<Item = IdTriple> + Send>>

Returns 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
) -> Result<Box<dyn Iterator<Item = IdTriple> + Send>>

Returns 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
) -> Result<Box<dyn Iterator<Item = IdTriple> + Send>>

Returns 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
) -> Result<Box<dyn Iterator<Item = IdTriple> + Send>>

Returns 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
) -> Result<Box<dyn Iterator<Item = IdTriple> + Send>>

Returns 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) -> Result<usize>

Returns 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) -> Result<usize>

Returns 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) -> Result<Vec<[u32; 5]>>

Returns 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 SyncStoreLayer

fn clone(&self) -> SyncStoreLayer

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Layer for SyncStoreLayer

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.