Struct Database

pub struct Database {
    pub path: String,
    /* private fields */
}

The main struct of Dino. The Database struct is responsible for creating the storage instance that will store this database’s documents, managing the database tables as well as providing access to the default table.

Fields

path: String

The path of the file in a String format

Implementations

impl Database

pub fn new(path: &str) -> Database

Create a new instance of the Database

Examples found in repository

examples/database.rs (line 7)

fn main() {
    // Create the database instance
    let mut db = Database::new("./hello.dino");

    // Load and create the database if does not exist
    db.load();

    // Insert values in the db in the format of key, value
    db.insert("key", "q");

    // Create a new sub Tree in the main Tree of the db
    let mut data_tree = Tree::new();

    // Insert the key and value in the sub tree
    data_tree.insert("b", "c");

    // The length of items in the sub tree in the database
    // This also shows almost all of the functions in Database are also avaliable in Tree
    println!("The length of items in the sub tree in the database is: {}", data_tree.len());

    // Insert the [data_tree] under the main tree
    db.insert_tree("id", data_tree);

    // Print the value of id
    println!("The value of key: id is:\n{}", db.find("id").unwrap());

    match db.find("not_exists") {
        Ok(_value) => {
            println!("This is unfortunate :(")
        }

        Err(error) => {
            println!("Everting works! Here is the error for reference: {}", error)
        }
    }

    // Remove a key in the database with its value
    db.remove("id");

    // Now here it wont print that it exists as it does not we removed it ^^^^^
    if db.contains_key("id") {
        println!("The key `id` exists!")
    };

    println!("The length of items in the database is: {}", db.len());

    // Insert a number in the database
    db.insert_number("test", 1);

    println!("{}", db.find("test").unwrap().to_number() + 1); // This will print 2
}

pub fn load(&mut self)

Load the database from the file and initialize variables

Examples found in repository

examples/database.rs (line 10)

fn main() {
    // Create the database instance
    let mut db = Database::new("./hello.dino");

    // Load and create the database if does not exist
    db.load();

    // Insert values in the db in the format of key, value
    db.insert("key", "q");

    // Create a new sub Tree in the main Tree of the db
    let mut data_tree = Tree::new();

    // Insert the key and value in the sub tree
    data_tree.insert("b", "c");

    // The length of items in the sub tree in the database
    // This also shows almost all of the functions in Database are also avaliable in Tree
    println!("The length of items in the sub tree in the database is: {}", data_tree.len());

    // Insert the [data_tree] under the main tree
    db.insert_tree("id", data_tree);

    // Print the value of id
    println!("The value of key: id is:\n{}", db.find("id").unwrap());

    match db.find("not_exists") {
        Ok(_value) => {
            println!("This is unfortunate :(")
        }

        Err(error) => {
            println!("Everting works! Here is the error for reference: {}", error)
        }
    }

    // Remove a key in the database with its value
    db.remove("id");

    // Now here it wont print that it exists as it does not we removed it ^^^^^
    if db.contains_key("id") {
        println!("The key `id` exists!")
    };

    println!("The length of items in the database is: {}", db.len());

    // Insert a number in the database
    db.insert_number("test", 1);

    println!("{}", db.find("test").unwrap().to_number() + 1); // This will print 2
}

pub fn insert_tree(&self, key: &str, value: Tree)

Insert a key with a subtree in the database

Examples found in repository

examples/database.rs (line 26)

fn main() {
    // Create the database instance
    let mut db = Database::new("./hello.dino");

    // Load and create the database if does not exist
    db.load();

    // Insert values in the db in the format of key, value
    db.insert("key", "q");

    // Create a new sub Tree in the main Tree of the db
    let mut data_tree = Tree::new();

    // Insert the key and value in the sub tree
    data_tree.insert("b", "c");

    // The length of items in the sub tree in the database
    // This also shows almost all of the functions in Database are also avaliable in Tree
    println!("The length of items in the sub tree in the database is: {}", data_tree.len());

    // Insert the [data_tree] under the main tree
    db.insert_tree("id", data_tree);

    // Print the value of id
    println!("The value of key: id is:\n{}", db.find("id").unwrap());

    match db.find("not_exists") {
        Ok(_value) => {
            println!("This is unfortunate :(")
        }

        Err(error) => {
            println!("Everting works! Here is the error for reference: {}", error)
        }
    }

    // Remove a key in the database with its value
    db.remove("id");

    // Now here it wont print that it exists as it does not we removed it ^^^^^
    if db.contains_key("id") {
        println!("The key `id` exists!")
    };

    println!("The length of items in the database is: {}", db.len());

    // Insert a number in the database
    db.insert_number("test", 1);

    println!("{}", db.find("test").unwrap().to_number() + 1); // This will print 2
}

pub fn insert(&self, key: &str, value: &str)

Insert a key and a value in the database

Examples found in repository

examples/database.rs (line 13)

fn main() {
    // Create the database instance
    let mut db = Database::new("./hello.dino");

    // Load and create the database if does not exist
    db.load();

    // Insert values in the db in the format of key, value
    db.insert("key", "q");

    // Create a new sub Tree in the main Tree of the db
    let mut data_tree = Tree::new();

    // Insert the key and value in the sub tree
    data_tree.insert("b", "c");

    // The length of items in the sub tree in the database
    // This also shows almost all of the functions in Database are also avaliable in Tree
    println!("The length of items in the sub tree in the database is: {}", data_tree.len());

    // Insert the [data_tree] under the main tree
    db.insert_tree("id", data_tree);

    // Print the value of id
    println!("The value of key: id is:\n{}", db.find("id").unwrap());

    match db.find("not_exists") {
        Ok(_value) => {
            println!("This is unfortunate :(")
        }

        Err(error) => {
            println!("Everting works! Here is the error for reference: {}", error)
        }
    }

    // Remove a key in the database with its value
    db.remove("id");

    // Now here it wont print that it exists as it does not we removed it ^^^^^
    if db.contains_key("id") {
        println!("The key `id` exists!")
    };

    println!("The length of items in the database is: {}", db.len());

    // Insert a number in the database
    db.insert_number("test", 1);

    println!("{}", db.find("test").unwrap().to_number() + 1); // This will print 2
}

pub fn insert_number(&self, key: &str, value: usize)

Insert a key and a value in the database

Examples found in repository

examples/database.rs (line 52)

fn main() {
    // Create the database instance
    let mut db = Database::new("./hello.dino");

    // Load and create the database if does not exist
    db.load();

    // Insert values in the db in the format of key, value
    db.insert("key", "q");

    // Create a new sub Tree in the main Tree of the db
    let mut data_tree = Tree::new();

    // Insert the key and value in the sub tree
    data_tree.insert("b", "c");

    // The length of items in the sub tree in the database
    // This also shows almost all of the functions in Database are also avaliable in Tree
    println!("The length of items in the sub tree in the database is: {}", data_tree.len());

    // Insert the [data_tree] under the main tree
    db.insert_tree("id", data_tree);

    // Print the value of id
    println!("The value of key: id is:\n{}", db.find("id").unwrap());

    match db.find("not_exists") {
        Ok(_value) => {
            println!("This is unfortunate :(")
        }

        Err(error) => {
            println!("Everting works! Here is the error for reference: {}", error)
        }
    }

    // Remove a key in the database with its value
    db.remove("id");

    // Now here it wont print that it exists as it does not we removed it ^^^^^
    if db.contains_key("id") {
        println!("The key `id` exists!")
    };

    println!("The length of items in the database is: {}", db.len());

    // Insert a number in the database
    db.insert_number("test", 1);

    println!("{}", db.find("test").unwrap().to_number() + 1); // This will print 2
}

pub fn remove(&self, key: &str)

Remove a key in the database with its value

Examples found in repository

examples/database.rs (line 42)

fn main() {
    // Create the database instance
    let mut db = Database::new("./hello.dino");

    // Load and create the database if does not exist
    db.load();

    // Insert values in the db in the format of key, value
    db.insert("key", "q");

    // Create a new sub Tree in the main Tree of the db
    let mut data_tree = Tree::new();

    // Insert the key and value in the sub tree
    data_tree.insert("b", "c");

    // The length of items in the sub tree in the database
    // This also shows almost all of the functions in Database are also avaliable in Tree
    println!("The length of items in the sub tree in the database is: {}", data_tree.len());

    // Insert the [data_tree] under the main tree
    db.insert_tree("id", data_tree);

    // Print the value of id
    println!("The value of key: id is:\n{}", db.find("id").unwrap());

    match db.find("not_exists") {
        Ok(_value) => {
            println!("This is unfortunate :(")
        }

        Err(error) => {
            println!("Everting works! Here is the error for reference: {}", error)
        }
    }

    // Remove a key in the database with its value
    db.remove("id");

    // Now here it wont print that it exists as it does not we removed it ^^^^^
    if db.contains_key("id") {
        println!("The key `id` exists!")
    };

    println!("The length of items in the database is: {}", db.len());

    // Insert a number in the database
    db.insert_number("test", 1);

    println!("{}", db.find("test").unwrap().to_number() + 1); // This will print 2
}

pub fn find(&self, key: &str) -> Result<Value, String>

Find a value in the db

Examples found in repository

examples/database.rs (line 29)

fn main() {
    // Create the database instance
    let mut db = Database::new("./hello.dino");

    // Load and create the database if does not exist
    db.load();

    // Insert values in the db in the format of key, value
    db.insert("key", "q");

    // Create a new sub Tree in the main Tree of the db
    let mut data_tree = Tree::new();

    // Insert the key and value in the sub tree
    data_tree.insert("b", "c");

    // The length of items in the sub tree in the database
    // This also shows almost all of the functions in Database are also avaliable in Tree
    println!("The length of items in the sub tree in the database is: {}", data_tree.len());

    // Insert the [data_tree] under the main tree
    db.insert_tree("id", data_tree);

    // Print the value of id
    println!("The value of key: id is:\n{}", db.find("id").unwrap());

    match db.find("not_exists") {
        Ok(_value) => {
            println!("This is unfortunate :(")
        }

        Err(error) => {
            println!("Everting works! Here is the error for reference: {}", error)
        }
    }

    // Remove a key in the database with its value
    db.remove("id");

    // Now here it wont print that it exists as it does not we removed it ^^^^^
    if db.contains_key("id") {
        println!("The key `id` exists!")
    };

    println!("The length of items in the database is: {}", db.len());

    // Insert a number in the database
    db.insert_number("test", 1);

    println!("{}", db.find("test").unwrap().to_number() + 1); // This will print 2
}

pub fn contains_key(&self, key: &str) -> bool

Check if the key exists in the database

Examples found in repository

examples/database.rs (line 45)

fn main() {
    // Create the database instance
    let mut db = Database::new("./hello.dino");

    // Load and create the database if does not exist
    db.load();

    // Insert values in the db in the format of key, value
    db.insert("key", "q");

    // Create a new sub Tree in the main Tree of the db
    let mut data_tree = Tree::new();

    // Insert the key and value in the sub tree
    data_tree.insert("b", "c");

    // The length of items in the sub tree in the database
    // This also shows almost all of the functions in Database are also avaliable in Tree
    println!("The length of items in the sub tree in the database is: {}", data_tree.len());

    // Insert the [data_tree] under the main tree
    db.insert_tree("id", data_tree);

    // Print the value of id
    println!("The value of key: id is:\n{}", db.find("id").unwrap());

    match db.find("not_exists") {
        Ok(_value) => {
            println!("This is unfortunate :(")
        }

        Err(error) => {
            println!("Everting works! Here is the error for reference: {}", error)
        }
    }

    // Remove a key in the database with its value
    db.remove("id");

    // Now here it wont print that it exists as it does not we removed it ^^^^^
    if db.contains_key("id") {
        println!("The key `id` exists!")
    };

    println!("The length of items in the database is: {}", db.len());

    // Insert a number in the database
    db.insert_number("test", 1);

    println!("{}", db.find("test").unwrap().to_number() + 1); // This will print 2
}

pub fn len(&self) -> usize

Return the length of items that are in the main tree

Examples found in repository

examples/database.rs (line 49)

fn main() {
    // Create the database instance
    let mut db = Database::new("./hello.dino");

    // Load and create the database if does not exist
    db.load();

    // Insert values in the db in the format of key, value
    db.insert("key", "q");

    // Create a new sub Tree in the main Tree of the db
    let mut data_tree = Tree::new();

    // Insert the key and value in the sub tree
    data_tree.insert("b", "c");

    // The length of items in the sub tree in the database
    // This also shows almost all of the functions in Database are also avaliable in Tree
    println!("The length of items in the sub tree in the database is: {}", data_tree.len());

    // Insert the [data_tree] under the main tree
    db.insert_tree("id", data_tree);

    // Print the value of id
    println!("The value of key: id is:\n{}", db.find("id").unwrap());

    match db.find("not_exists") {
        Ok(_value) => {
            println!("This is unfortunate :(")
        }

        Err(error) => {
            println!("Everting works! Here is the error for reference: {}", error)
        }
    }

    // Remove a key in the database with its value
    db.remove("id");

    // Now here it wont print that it exists as it does not we removed it ^^^^^
    if db.contains_key("id") {
        println!("The key `id` exists!")
    };

    println!("The length of items in the database is: {}", db.len());

    // Insert a number in the database
    db.insert_number("test", 1);

    println!("{}", db.find("test").unwrap().to_number() + 1); // This will print 2
}

Trait Implementations

impl Display for Database

impl Display for database So we can print the whole tree to the display

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

Formats the value using the given formatter.