Struct Et

pub struct Et {
    pub conn: Connection,
    pub collections: HashMap<String, Collection>,
}

Fields

conn: Connection

collections: HashMap<String, Collection>

Implementations

impl Et

pub fn new<P: AsRef<Path>>(path: P) -> Et

Examples found in repository

examples/store_query.rs (line 11)

fn main() -> Result<(), et::Error> {
    let mut pot = Et::new(".");

    // lets make a new collection
    pot.create_collection("address_book")?;

    // well make a new item we want to store
    let person = Person {
        name: String::from("david holtz"),
        age: 26,
    };

    // we insert the object into the collection!
    pot.insert::<Person>("address_book", &person)?;

    // before we query we can add an index to speed things up
    pot.add_index_to_collection("address_book", "name", "naming_index")?;

    // finally we can query
    let query = QueryBuilder::new()
        .collection("address_book")
        .kind(QueryKind::Object)
        .key("name")
        .comparison("=")
        .string("david holtz")
        .finish();

    let results = pot.execute(query);
    println!("{:#?}", results);

    Ok(())
}

pub fn close(self)

pub fn list_collections(&mut self) -> Result<Vec<String>>

pub fn create_collection(&mut self, name: &str) -> Result<bool, Error>

Examples found in repository

examples/store_query.rs (line 14)

fn main() -> Result<(), et::Error> {
    let mut pot = Et::new(".");

    // lets make a new collection
    pot.create_collection("address_book")?;

    // well make a new item we want to store
    let person = Person {
        name: String::from("david holtz"),
        age: 26,
    };

    // we insert the object into the collection!
    pot.insert::<Person>("address_book", &person)?;

    // before we query we can add an index to speed things up
    pot.add_index_to_collection("address_book", "name", "naming_index")?;

    // finally we can query
    let query = QueryBuilder::new()
        .collection("address_book")
        .kind(QueryKind::Object)
        .key("name")
        .comparison("=")
        .string("david holtz")
        .finish();

    let results = pot.execute(query);
    println!("{:#?}", results);

    Ok(())
}

pub fn execute(&self, query: Query) -> Result<Vec<Entry>, Error>

Examples found in repository

examples/store_query.rs (line 37)

fn main() -> Result<(), et::Error> {
    let mut pot = Et::new(".");

    // lets make a new collection
    pot.create_collection("address_book")?;

    // well make a new item we want to store
    let person = Person {
        name: String::from("david holtz"),
        age: 26,
    };

    // we insert the object into the collection!
    pot.insert::<Person>("address_book", &person)?;

    // before we query we can add an index to speed things up
    pot.add_index_to_collection("address_book", "name", "naming_index")?;

    // finally we can query
    let query = QueryBuilder::new()
        .collection("address_book")
        .kind(QueryKind::Object)
        .key("name")
        .comparison("=")
        .string("david holtz")
        .finish();

    let results = pot.execute(query);
    println!("{:#?}", results);

    Ok(())
}

pub fn add_object_to_collection( &mut self, cname: &str, val: String, ) -> Result<bool, Error>

pub fn add_index_to_collection( &mut self, collection_name: &str, key: &str, index_name: &str, ) -> Result<bool, Error>

Examples found in repository

examples/store_query.rs (line 26)

fn main() -> Result<(), et::Error> {
    let mut pot = Et::new(".");

    // lets make a new collection
    pot.create_collection("address_book")?;

    // well make a new item we want to store
    let person = Person {
        name: String::from("david holtz"),
        age: 26,
    };

    // we insert the object into the collection!
    pot.insert::<Person>("address_book", &person)?;

    // before we query we can add an index to speed things up
    pot.add_index_to_collection("address_book", "name", "naming_index")?;

    // finally we can query
    let query = QueryBuilder::new()
        .collection("address_book")
        .kind(QueryKind::Object)
        .key("name")
        .comparison("=")
        .string("david holtz")
        .finish();

    let results = pot.execute(query);
    println!("{:#?}", results);

    Ok(())
}

pub fn insert<T: Serialize>( &mut self, cname: &str, svalue: &T, ) -> Result<bool, Error>

Examples found in repository

examples/store_query.rs (line 23)

fn main() -> Result<(), et::Error> {
    let mut pot = Et::new(".");

    // lets make a new collection
    pot.create_collection("address_book")?;

    // well make a new item we want to store
    let person = Person {
        name: String::from("david holtz"),
        age: 26,
    };

    // we insert the object into the collection!
    pot.insert::<Person>("address_book", &person)?;

    // before we query we can add an index to speed things up
    pot.add_index_to_collection("address_book", "name", "naming_index")?;

    // finally we can query
    let query = QueryBuilder::new()
        .collection("address_book")
        .kind(QueryKind::Object)
        .key("name")
        .comparison("=")
        .string("david holtz")
        .finish();

    let results = pot.execute(query);
    println!("{:#?}", results);

    Ok(())
}

pub fn upsert_at_index<T: Serialize>( &mut self, cname: &str, index: usize, svalue: &T, ) -> Result<bool, Error>

Trait Implementations

impl Debug for Et

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

Formats the value using the given formatter.