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_row(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(&mut 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 get_name(&self) -> String

Returns the filename of the database

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

Returns a new Data::DbString

pub fn db_i32(v: i32) -> Data

Returns a new Data::DbI32

pub fn find_first_i32(&self, name: &str) -> Option<i32>

Find a i32 by name

use vdb::{Db, Entry};
let mut db = Db::new("test-db");
let name = "yoyo";
let value = 7;
let _row_id = db.add_row(vec![Entry::new_i32(name, value)]);
assert_eq!(db.find_first_i32(name), Some(value));

pub fn find_first_string(&self, name: &str) -> Option<String>

Find a string by name

use vdb::{Db, Entry};
let mut db = Db::new("test-db");
let name = "yoyo";
let value = "lila";
let _row_id = db.add_row(vec![Entry::new_string(name, value)]);
assert_eq!(db.find_first_string(name), Some(value.to_string()));

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_i32(&mut self, name: &str, value: i32) -> RowId

Add a new row with one i32

pub fn add_string(&mut self, name: &str, value: &str) -> RowId

Add a new row with one string

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

Add a new row with multiple entries.

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

Add a single entry to an existing row. An existing entry with the same name is overwritten. If multiple entries with the same name exist, they will be overwritten.

pub fn remove_by_name(&mut self, row_id: RowId, name: &str)

Removes all entries with name 'name' and row 'row_id'. Does not delete the whole row and leaves entries with other names.

pub fn remove_by_row_id(&mut self, row_id: RowId)

Removes all entries with row 'row_id'

pub fn add_row_id_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_row(vec![
        Entry::new_string("word", "cocina"),
        Entry::new_string("translation", "cuisine"),
        Entry::new_string("translation", "kitchen"),
]);
let row_2 = db.add_row(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. Does not delete all rows. Deletes matching entries in the row. The row will be kept if there are entries left, otherwise deleted.

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

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

pub fn find_row_ids_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 find_first_entry_by_name(
    &self,
    row_id: RowId,
    name: &str
) -> Option<Entry>

Return reference to first entry found in a given row.

pub fn find_by_predicate(&self, predicate: &Predicate) -> Vec<RowId>

pub fn find_row_ids_by_predicate(
    &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_row(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 row_ids = db.find_row_ids_by_predicate(&predicates, Some(15));
assert_eq!(row_ids, [RowId(1)]);
assert_eq!(db.entries_from_row_ids(&row_ids, &["name", "value"])[0][0], Entry::new_string("name", "coche"));

See also find_entries_by_predicate()

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: &[&str]
) -> Vec<Vec<Entry>>

Returns entries for given row_ids.

Trait Implementations

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 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 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.