Struct quick_kv::client::mini::QuickClientMini

source ·

pub struct QuickClientMini {
    pub file: Arc<Mutex<File>>,
    pub cache: Arc<Mutex<HashMap<String, BinaryKvCache>>>,
}

Expand description

The Mini Client. Used for simple data storage and retrieval.

Example

use std::collections::HashMap;

use quick_kv::prelude::*;

let mut client = QuickClientMini::new(None).unwrap();

let mut map = HashMap::new();

for i in 0..9 {
    map.insert(i.to_string(), i);
}

client
    .set("test-hash", TypedValue::<i32>::Hash(map.clone()))
    .unwrap();

let map_results = client
    .get::<TypedValue<i32>>("test-hash")
    .unwrap()
    .unwrap()
    .into_hash();

for (key, value) in map_results.iter() {
    println!("{}: {}", key, value)
}

assert_eq!(map, map_results);

Fields§

§file: Arc<Mutex<File>>§cache: Arc<Mutex<HashMap<String, BinaryKvCache>>>

Implementations§

source §

impl QuickClientMini

source

pub fn new(path: Option<&str>) -> Result<Self>

Creates a new instance of the client.

path to the database file. If None is provided, the database will be created in the current working directory and default to db.qkv.

You can have as many client instances as you want, however, if you have multiple instances of the same client, you need to make sure they write to different databases or else there will be data corruption.

source

pub fn get<T>(&mut self, key: &str) -> Result<Option<T>>
where T: Serialize + DeserializeOwned + Clone + Debug,

Get a value from the database.

key to get the value for.

Returns Some(T) if the key exists, None if the key does not exist.

use quick_kv::prelude::*;

let mut client = QuickClientMini::new(None).unwrap();

let result = client.get::<i32>("doesnotexist").unwrap();

assert_eq!(result, None);

source

pub fn set<T>(&mut self, key: &str, value: T) -> Result<()>
where T: Serialize + DeserializeOwned + Clone + Debug,

Set a value in the database.

key to set the value for.

value to set for the key.

use quick_kv::prelude::*;

let mut client = QuickClientMini::new(None).unwrap();

client.set("five", Value::I32(5).into_i32()).unwrap();

let five = client.get::<i32>("five").unwrap().unwrap();

assert_eq!(five, 5);

source

pub fn delete<T>(&mut self, key: &str) -> Result<()>
where T: Serialize + DeserializeOwned + Clone + Debug,

Delete a value from the database.

key to delete the value for.

use quick_kv::prelude::*;

let mut client = QuickClientMini::new(None).unwrap();

client.set("five", Value::I32(5).into_i32()).unwrap();

client.delete::<i32>("five").unwrap();

let should_not_exist = client.get::<i32>("five").unwrap();

assert_eq!(should_not_exist, None);

source

pub fn update<T>(&mut self, key: &str, value: T) -> Result<()>
where T: Serialize + DeserializeOwned + Clone + Debug,

Update a value in the database.

key to update the value for.

value to update for the key.

use quick_kv::prelude::*;

let mut client = QuickClientMini::new(None).unwrap();

client.set("five", Value::I32(5).into_i32()).unwrap();
let five = client.get::<i32>("five").unwrap().unwrap();
assert_eq!(five, 5);

client.update("five", 10).unwrap();
let ten = client.get::<i32>("five").unwrap().unwrap();
assert_eq!(ten, 10);