Struct Db

pub struct Db { /* private fields */ }

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")]);

Implementations

impl Db

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

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

Examples found in repository

examples/notebook.rs (line 105)

fn main() {
    let db_name = "notebook";
    let mut db = if let Ok(db) = Db::load(db_name) {
        db
    } else {
        Db::new(db_name)
    };
    main_loop(&mut db);
}

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.

Examples found in repository

examples/notebook.rs (line 102)

fn main() {
    let db_name = "notebook";
    let mut db = if let Ok(db) = Db::load(db_name) {
        db
    } else {
        Db::new(db_name)
    };
    main_loop(&mut db);
}

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.

Examples found in repository

examples/notebook.rs (line 90)

fn main_loop(db: &mut Db) {
    let mut input = "".to_string();
    print_menu();
    while let Ok(_bytes_read) = io::stdin().read_line(&mut input) {
        let trimmed = input.trim();
        match trimmed {
            "l" => list_entries(db),
            "e" => new_entry(db),
            "d" => delete_entry(db),
            "" | "q" => {
                let _ = db.save();
                break;
            }
            _ => (),
        }
        print_menu();
        input.clear();
    }
}

pub fn get_name(&self) -> String

Returns the filename of the database

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

Returns a new Data::DbString

Examples found in repository

examples/notebook.rs (line 60)

fn delete_entry(db: &mut Db) {
    println!("Enter title to delete:");
    print!("> ");
    io::stdout().flush().unwrap();

    let mut input = "".to_string();
    let title = {
        let _bytes_read = io::stdin().read_line(&mut input).unwrap();
        input.trim()
    };
    if !title.is_empty() {
        let row_ids = db.find_row_ids_by_value("title", &Db::db_string(title));
        db.delete_rows(&row_ids);
    } else {
        println!("Abort.");
    }
}

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.

Examples found in repository

examples/notebook.rs (lines 40-43)

fn new_entry(db: &mut Db) {
    println!("Enter title:");
    print!("> ");
    io::stdout().flush().unwrap();

    let mut input = "".to_string();
    let title = {
        let _bytes_read = io::stdin().read_line(&mut input).unwrap();
        input.trim()
    };
    if !title.is_empty() {
        println!("Enter text:");
        print!("> ");
        io::stdout().flush().unwrap();
        let mut input = "".to_string();
        let _bytes_read = io::stdin().read_line(&mut input).unwrap();
        let text = input.trim();
        db.add_row(vec![
            Entry::new_string("title", title),
            Entry::new_string("text", text),
        ]);
    } else {
        println!("Abort.");
    }
}

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);

Examples found in repository

examples/notebook.rs (line 61)

fn delete_entry(db: &mut Db) {
    println!("Enter title to delete:");
    print!("> ");
    io::stdout().flush().unwrap();

    let mut input = "".to_string();
    let title = {
        let _bytes_read = io::stdin().read_line(&mut input).unwrap();
        input.trim()
    };
    if !title.is_empty() {
        let row_ids = db.find_row_ids_by_value("title", &Db::db_string(title));
        db.delete_rows(&row_ids);
    } else {
        println!("Abort.");
    }
}

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.

Examples found in repository

examples/notebook.rs (line 9)

fn list_entries(db: &mut Db) {
    let row_ids = db.find_row_ids_by_name("title");
    let entries = db.entries_from_row_ids(&row_ids, &["title", "text"]);
    if entries.is_empty() {
        println!();
        println!("No entries.");
    } else {
        for entry in &entries {
            if entry.len() >= 2 {
                println!("{}: {}", entry[0].value, entry[1].value);
            }
        }
    }
}

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.

Examples found in repository

examples/notebook.rs (line 60)

fn delete_entry(db: &mut Db) {
    println!("Enter title to delete:");
    print!("> ");
    io::stdout().flush().unwrap();

    let mut input = "".to_string();
    let title = {
        let _bytes_read = io::stdin().read_line(&mut input).unwrap();
        input.trim()
    };
    if !title.is_empty() {
        let row_ids = db.find_row_ids_by_value("title", &Db::db_string(title));
        db.delete_rows(&row_ids);
    } else {
        println!("Abort.");
    }
}

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.

Examples found in repository

examples/notebook.rs (line 10)

fn list_entries(db: &mut Db) {
    let row_ids = db.find_row_ids_by_name("title");
    let entries = db.entries_from_row_ids(&row_ids, &["title", "text"]);
    if entries.is_empty() {
        println!();
        println!("No entries.");
    } else {
        for entry in &entries {
            if entry.len() >= 2 {
                println!("{}: {}", entry[0].value, entry[1].value);
            }
        }
    }
}

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 Debug for Db

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

Formats the value using the given formatter.

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.

impl PartialEq for Db

fn eq(&self, other: &Db) -> 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.

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 StructuralPartialEq for Db