Struct StoreLayer 

pub struct StoreLayer { /* private fields */ }

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.

Examples found in repository

examples/write_to_graph.rs (line 65)

async fn process_commands(store_path: &str, graph: &str) -> io::Result<()> {
    let store = open_directory_store(store_path);
    let graph = store
        .open(graph)
        .await?
        .expect(&format!("expected graph {} to exist", graph));

    // There are two types of builders. One creates a new base layer,
    // which has no parent. The other creates a child layer, which has
    // another layer as its parent.
    let builder = match graph.head().await? {
        Some(layer) => layer.open_write().await?,
        None => store.create_base_layer().await?,
    };
    let mut stdin = io::BufReader::new(io::stdin()).lines();

    while let Some(line) = stdin.next_line().await? {
        let segment = line.trim();
        if segment.len() == 0 {
            continue;
        }

        let command = parse_command(segment).await?;

        // add all the input data into the builder.
        // The builder keeps an in-memory list of added and removed
        // triples. If the same triple is added and removed on the
        // same builder, it is a no-op. This is even the case when it
        // is then later re-added on the same builder.
        //
        // Since no io is happening, adding triples to the builder is
        // not a future.
        match command {
            Command::Add(triple) => builder.add_value_triple(triple)?,
            Command::Remove(triple) => builder.remove_value_triple(triple)?,
        }
    }

    // When commit is called, the builder writes its data to
    // persistent storage.
    let layer = builder.commit().await?;

    // While a layer exists now, it's not yet attached to anything,
    // and is therefore unusable unless you know the exact identifier
    // of the layer itself. To make this the graph data, we have to
    // set the grap head to this layer.
    graph.set_head(&layer).await?;

    println!(
        "Added: {}, removed: {}",
        layer.triple_layer_addition_count().await?,
        layer.triple_layer_removal_count().await?
    );

    Ok(())
}

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_upto(&self, upto: &StoreLayer) -> Result<StoreLayer>

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 async fn imprecise_rollup_upto(&self, upto: &StoreLayer) -> Result<()>

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 async fn triple_addition_exists( &self, subject: u64, predicate: u64, object: u64, ) -> Result<bool>

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 async fn triple_removal_exists( &self, subject: u64, predicate: u64, object: u64, ) -> Result<bool>

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 async fn triple_additions( &self, ) -> Result<Box<dyn Iterator<Item = IdTriple> + 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 async fn triple_removals( &self, ) -> Result<Box<dyn Iterator<Item = IdTriple> + 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 async fn triple_additions_s( &self, subject: u64, ) -> Result<Box<dyn Iterator<Item = IdTriple> + 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 async fn triple_removals_s( &self, subject: u64, ) -> Result<Box<dyn Iterator<Item = IdTriple> + 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 async fn triple_additions_sp( &self, subject: u64, predicate: u64, ) -> Result<Box<dyn Iterator<Item = IdTriple> + 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 async fn triple_removals_sp( &self, subject: u64, predicate: u64, ) -> Result<Box<dyn Iterator<Item = IdTriple> + 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 async fn triple_additions_p( &self, predicate: u64, ) -> Result<Box<dyn Iterator<Item = IdTriple> + 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 async fn triple_removals_p( &self, predicate: u64, ) -> Result<Box<dyn Iterator<Item = IdTriple> + 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 async fn triple_additions_o( &self, object: u64, ) -> Result<Box<dyn Iterator<Item = IdTriple> + 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 async fn triple_removals_o( &self, object: u64, ) -> Result<Box<dyn Iterator<Item = IdTriple> + 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 async fn triple_layer_addition_count(&self) -> Result<usize>

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.

Examples found in repository

examples/write_to_graph.rs (line 104)

async fn process_commands(store_path: &str, graph: &str) -> io::Result<()> {
    let store = open_directory_store(store_path);
    let graph = store
        .open(graph)
        .await?
        .expect(&format!("expected graph {} to exist", graph));

    // There are two types of builders. One creates a new base layer,
    // which has no parent. The other creates a child layer, which has
    // another layer as its parent.
    let builder = match graph.head().await? {
        Some(layer) => layer.open_write().await?,
        None => store.create_base_layer().await?,
    };
    let mut stdin = io::BufReader::new(io::stdin()).lines();

    while let Some(line) = stdin.next_line().await? {
        let segment = line.trim();
        if segment.len() == 0 {
            continue;
        }

        let command = parse_command(segment).await?;

        // add all the input data into the builder.
        // The builder keeps an in-memory list of added and removed
        // triples. If the same triple is added and removed on the
        // same builder, it is a no-op. This is even the case when it
        // is then later re-added on the same builder.
        //
        // Since no io is happening, adding triples to the builder is
        // not a future.
        match command {
            Command::Add(triple) => builder.add_value_triple(triple)?,
            Command::Remove(triple) => builder.remove_value_triple(triple)?,
        }
    }

    // When commit is called, the builder writes its data to
    // persistent storage.
    let layer = builder.commit().await?;

    // While a layer exists now, it's not yet attached to anything,
    // and is therefore unusable unless you know the exact identifier
    // of the layer itself. To make this the graph data, we have to
    // set the grap head to this layer.
    graph.set_head(&layer).await?;

    println!(
        "Added: {}, removed: {}",
        layer.triple_layer_addition_count().await?,
        layer.triple_layer_removal_count().await?
    );

    Ok(())
}

pub async fn triple_layer_removal_count(&self) -> Result<usize>

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.

Examples found in repository

examples/write_to_graph.rs (line 105)

async fn process_commands(store_path: &str, graph: &str) -> io::Result<()> {
    let store = open_directory_store(store_path);
    let graph = store
        .open(graph)
        .await?
        .expect(&format!("expected graph {} to exist", graph));

    // There are two types of builders. One creates a new base layer,
    // which has no parent. The other creates a child layer, which has
    // another layer as its parent.
    let builder = match graph.head().await? {
        Some(layer) => layer.open_write().await?,
        None => store.create_base_layer().await?,
    };
    let mut stdin = io::BufReader::new(io::stdin()).lines();

    while let Some(line) = stdin.next_line().await? {
        let segment = line.trim();
        if segment.len() == 0 {
            continue;
        }

        let command = parse_command(segment).await?;

        // add all the input data into the builder.
        // The builder keeps an in-memory list of added and removed
        // triples. If the same triple is added and removed on the
        // same builder, it is a no-op. This is even the case when it
        // is then later re-added on the same builder.
        //
        // Since no io is happening, adding triples to the builder is
        // not a future.
        match command {
            Command::Add(triple) => builder.add_value_triple(triple)?,
            Command::Remove(triple) => builder.remove_value_triple(triple)?,
        }
    }

    // When commit is called, the builder writes its data to
    // persistent storage.
    let layer = builder.commit().await?;

    // While a layer exists now, it's not yet attached to anything,
    // and is therefore unusable unless you know the exact identifier
    // of the layer itself. To make this the graph data, we have to
    // set the grap head to this layer.
    graph.set_head(&layer).await?;

    println!(
        "Added: {}, removed: {}",
        layer.triple_layer_addition_count().await?,
        layer.triple_layer_removal_count().await?
    );

    Ok(())
}

pub async fn retrieve_layer_stack_names(&self) -> Result<Vec<[u32; 5]>>

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 duplicate of the value.

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

Performs copy-assignment from source.

impl Eq for StoreLayer

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: &TypedDictEntry) -> 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 id_object_is_node(&self, id: u64) -> Option<bool>

Check if the given id refers to a node.

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 single_triple_sp(&self, subject: u64, predicate: u64) -> Option<IdTriple>

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

The object node corresponding to a numerical id, or None if it cannot be found. Panics if the object is actually a value.

fn id_object_value(&self, id: u64) -> Option<TypedDictEntry>

The object value corresponding to a numerical id, or None if it cannot be found. Panics if the object is actually a node.

fn id_object_is_value(&self, id: u64) -> Option<bool>

Check if the given id refers to a value.

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

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

fn value_triple_exists(&self, triple: &ValueTriple) -> bool

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

fn value_triple_to_id(&self, triple: &ValueTriple) -> Option<IdTriple>

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

fn value_triple_to_partially_resolved( &self, triple: ValueTriple, ) -> PartiallyResolvedTriple

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

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

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.

impl PartialEq for StoreLayer

fn eq(&self, other: &StoreLayer) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.