Struct vdb::Db

pub struct Db { /* fields omitted */ }

Container for the database. Usually only one is used per application.

Examples

use vdb::{Db, Entry};
let mut db = Db::new("test-db");
let _row_id = db.add(vec![Entry::new_string("mundo", "world")]);

Methods

impl Db

pub fn new(filename: &str) -> Db

Create new database in memory. The file is not created until save() is called.

pub fn load(filename: &str) -> Result<Db, Box<dyn Error>>

Load a database file from the filesystem under the subdirectory save/.

Errors

May return errors from external modules while opening the file or parsing the contents.

pub fn save(&self) -> Result<(), Box<dyn Error>>

Save database under the subdirectory save/ with the same name it was opened or created with. The subdirectory save/ must exist.

pub fn db_string(v: &str) -> Data

pub fn db_int(v: i32) -> Data

pub fn db_datetime(v: &str) -> Result<Data, Box<dyn Error>>

Parse &str into a DbDateTime. The format string is %Y-%m-%d %H:%M:%S.

pub fn add(&mut self, entries: Vec<Entry>) -> RowId

Add a new row with multiple entries.

pub fn add_or_update_entry(&mut self, row_id: RowId, entry: Entry)

Add a single entry to an existing row. An existing entry with the same name is overwritten.

pub fn add_entry(&mut self, row_id: RowId, entry: Entry)

Add a single entry to an existing row. Does not check if entry exists.

pub fn delete_rows(&mut self, row_ids: &[RowId])

Delete rows in the database

Examples

use vdb::{Db, Entry};
let mut db = Db::new("test-db");
let row_1 = db.add(vec![
        Entry::new_string("word", "cocina"),
        Entry::new_string("translation", "cuisine"),
        Entry::new_string("translation", "kitchen"),
]);
let row_2 = db.add(vec![
        Entry::new_string("word", "coche"),
        Entry::new_string("translation", "car"),
]);
let coche = db.find_first_row_id_by_value("word", &Db::db_string("coche"));
assert_eq!(coche, Some(row_2));
db.delete_rows(&[row_1, row_2]);
let no_coche = db.find_first_row_id_by_value("word", &Db::db_string("coche"));
assert_eq!(no_coche, None);

pub fn delete_entry_all(&mut self, name: &str)

Delete all entries with this name in the whole database.

pub fn find_by_name(&self, name: &str) -> Vec<RowId>

Return row_ids of entries where an entry with name "name" exists.

pub fn find_by_value(&self, name: &str, value: &Data) -> Vec<RowId>

Return row_ids of entries that are exactly "value". For partial string matches, use Predicates.

pub fn find_first_row_id_by_name(&self, name: &str) -> Option<RowId>

Return reference to first entry found in a given row.

pub fn find_first_row_id_by_value(
    &self,
    name: &str,
    value: &Data
) -> Option<RowId>

Return reference to first entry found in a given row.

pub fn get_first_entry(&self, row_id: RowId, name: &str) -> Option<&Entry>

Return reference to first entry found in a given row.

pub fn get_first_entry_mut(
    &mut self,
    row_id: RowId,
    name: &str
) -> Option<&mut Entry>

Return mutable reference to an entry in a given row.

pub fn select_row_ids(
    &self,
    predicates: &[Predicate],
    max_results: Option<usize>
) -> Vec<RowId>

Returns all rows if no predicates are given. The first predicate is evaluated first and should have high selectivity, i. e. evaluate to a small number of rows, to improve execution time. The number of results can be limited with Some(max_results)

Examples

// Like SQL "select name, value from testdb where name='coche' limit 15"
use vdb::{Data, Db, Entry, Predicate, RowId};
let mut db = Db::new("test-db");
let _id = db.add(vec![
    Entry {
        name: String::from("set"),
        value: Db::db_string("es-en"),
    },
    Entry {
        name: String::from("name"),
        value: Db::db_string("coche"),
    },
    Entry {
        name: String::from("value"),
        value: Db::db_string("car"),
    },
]);
let predicates = vec![Predicate::new_equal_string("name", "coche")];
let entries = vec![String::from("name"), String::from("value")];
let row_ids = db.select_row_ids(&predicates, Some(15));
assert_eq!(row_ids, [RowId(1)]);
assert_eq!(db.entries_from_row_ids(&row_ids, entries)[0][0], Entry::new_string("name", "coche"));

See also select()

pub fn find_all_row_ids(&self) -> Vec<RowId>

Returns all rows in the database

pub fn entries_from_row_ids(
    &self,
    row_ids: &[RowId],
    names: Vec<String>
) -> Vec<Vec<Entry>>

Returns entries for given row_ids. The order of the entries in each row is not guaranteed.

Trait Implementations

impl PartialEq<Db> for Db

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl Clone for Db

fn clone(&self) -> Db

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Db

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Serialize for Db

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl<'de> Deserialize<'de> for Db

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.