Struct Store 

pub struct Store { /* private fields */ }

A store, storing a set of layers and database labels pointing to these layers.

Implementations

impl Store

pub fn new<Labels: 'static + LabelStore, Layers: 'static + LayerStore>( label_store: Labels, layer_store: Layers, ) -> Store

Create a new store from the given label and layer store.

pub async fn create(&self, label: &str) -> Result<NamedGraph>

Create a new database with the given name.

If the database already exists, this will return an error.

Examples found in repository

examples/create_graph.rs (line 16)

async fn main() {
    let args: Vec<String> = env::args().collect();
    if args.len() != 3 {
        println!("usage: {} <path> <graph_name>", args[0]);
    } else {
        // open a store at the given path. the directory has to exist.
        let store = open_directory_store(&args[1]);

        // then create a graph. if the graph already exists, this will error.
        store.create(&args[2]).await.unwrap();
    }
}

pub async fn open(&self, label: &str) -> Result<Option<NamedGraph>>

Open an existing database with the given name, or None if it does not exist.

Examples found in repository

examples/print_graph.rs (line 11)

async fn print_graph(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));

    match graph.head().await? {
        Some(layer) => {
            for id_triple in layer.triples() {
                // triples are retrieved in their id form. For printing,
                // we need the string form. The conversion happens here.
                let triple = layer
                    .id_triple_to_string(&id_triple)
                    .expect("expected id triple to be mapable to string");

                println!(
                    "{}, {}, {} {:?}",
                    triple.subject,
                    triple.predicate,
                    match triple.object {
                        ObjectType::Node(_) => "node",
                        ObjectType::Value(_) => "value",
                    },
                    match triple.object {
                        ObjectType::Node(n) => String::make_entry(&n),
                        ObjectType::Value(v) => v,
                    }
                );
            }
        }
        None => {}
    }

    Ok(())
}

examples/write_to_graph.rs (line 57)

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 delete(&self, label: &str) -> Result<bool>

Delete an existing database with the given name. Returns true if this database was deleted and false otherwise.

pub async fn labels(&self) -> Result<Vec<String>>

Return list of names of all existing databases.

pub async fn get_layer_from_id( &self, layer: [u32; 5], ) -> Result<Option<StoreLayer>>

Retrieve a layer with the given name from the layer store this Store was initialized with.

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

Create a base layer builder, unattached to any database label.

After having committed it, use set_head on a NamedGraph to attach it.

Examples found in repository

examples/write_to_graph.rs (line 66)

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 merge_base_layers( &self, layers: &[[u32; 5]], temp_dir: &Path, ) -> Result<[u32; 5]>

pub async fn export_layers( &self, layer_ids: Box<dyn Iterator<Item = [u32; 5]> + Send>, ) -> Result<Vec<u8>>

Export the given layers by creating a pack, a Vec that can later be used with import_layers on a different store.

pub async fn import_layers<'a>( &'a self, pack: &'a [u8], layer_ids: Box<dyn Iterator<Item = [u32; 5]> + Send>, ) -> Result<()>

Import the specified layers from the given pack, a byte slice that was previously generated with export_layers, on another store, and possibly even another machine).

After this operation, the specified layers will be retrievable from this store, provided they existed in the pack. specified layers that are not in the pack are silently ignored.

Trait Implementations

impl Clone for Store

fn clone(&self) -> Store

Returns a duplicate of the value.

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

Performs copy-assignment from source.