Struct eyros::DB

pub struct DB<S, U, P, V> where
    S: RandomAccess<Error = Error>,
    U: Fn(&str) -> Result<S, Error>,
    P: Point,
    V: Value,  {
    pub trees: Vec<Rc<RefCell<Tree<S, P, V>>>>,
    pub staging: Staging<S, P, V>,
    pub data_store: Rc<RefCell<DataStore<S, P, V>>>,
    pub fields: SetupFields,
    pub bincode: Rc<Config>,
    // some fields omitted
}

Top-level database API.

Fields

trees: Vec<Rc<RefCell<Tree<S, P, V>>>>

staging: Staging<S, P, V>

data_store: Rc<RefCell<DataStore<S, P, V>>>

fields: SetupFields

bincode: Rc<Config>

Methods

impl<S, U, P, V> DB<S, U, P, V> where
    S: RandomAccess<Error = Error>,
    U: Fn(&str) -> Result<S, Error>,
    P: Point,
    V: Value, 

pub fn open(open_store: U) -> Result<Self, Error>

Create a new database instance from open_store, a function that receives a string path as an argument and returns a Result with a RandomAccess store. The database will be created with the default configuration.

For example:

use eyros::DB;
use random_access_disk::RandomAccessDisk;
use std::path::PathBuf;
use failure::Error;

type P = ((f32,f32),(f32,f32));
type V = u32;

fn main () -> Result<(),Error> {
  let mut db: DB<_,_,P,V> = DB::open(storage)?;
  // ...
  Ok(())
}

fn storage (name: &str) -> Result<RandomAccessDisk,Error> {
  let mut p = PathBuf::from("/tmp/eyros-db/");
  p.push(name);
  Ok(RandomAccessDisk::builder(p).auto_sync(false).build()?)
}

pub fn open_from_setup(setup: Setup<S, U>) -> Result<Self, Error>

Create a new database instance from setup, a configuration builder.

let mut db: DB<_,_,P,V> = DB::open_from_setup(
  Setup::new(storage)
    .branch_factor(5)
    .max_data_size(3_000)
    .base_size(1_000)
)?;

You can also use Setup's .build()? method to get a DB instance:

use eyros::{DB,Setup};

let mut db: DB<_,_,P,V> = Setup::new(storage)
  .branch_factor(5)
  .max_data_size(3_000)
  .base_size(1_000)
  .build()?;

Always open a database with the same settings. Things will break if you change . There is no runtime check yet to ensure a database is opened with the same configuration that it was created with.

pub fn batch(&mut self, rows: &[Row<P, V>]) -> Result<(), Error>

Write a collection of updates to the database. Each update can be a Row::Insert(point,value) or a Row::Delete(location).

pub fn query<'b>(
    &mut self,
    bbox: &'b P::Bounds
) -> Result<QueryIterator<'b, S, P, V>, Error>

Query the database for all records that intersect the bounding box.

The bounding box is a 2-tuple of n-tuples (for an n-dimensional point type) representing the (min,max) coordinates. In 2d with a conventional x-y cartesian grid, the first bbox point would be the "bottom-left" (or west-south) and the second point would be the "top-right" (or east-north).

You will receive an iterator of Result<(P,V,Location),Error> results that you can step through like this:

let bbox = ((-0.5,-0.8),(0.3,-0.5));
for result in db.query(&bbox)? {
  let (point,value,location) = result?;
  // ...
}

If you want to delete records, you will need to use the Location records you get from a query. However, these locations are only valid until the next .batch().