Crate siamesedb

The simple local key-value store.

Features

• key-value store.
• in-memory and file store.
• DbMapDbString has keys as utf-8 string.
• DbMapDbInt has keys as u64.
• DbMapDbBytes has keys as Vec.
• The value is any bytes included utf-8 string.
• The file store is implemented the basic B-Tree. (no leaf)
• The file store is included the htx file that is hash cache table for performance.
• Small db file size.
• Separated files. (key file, value file, index file and htx file)
• One database has some db-map-string and some db-map-int and some db-map-bytes.
• Swiss army knife with easy-to-use and good performance
• minimum support rustc 1.56.1 (59eed8a2a 2021-11-01)

Compatibility

• Nothing?

Todo

• more performance
• DB lock as support for multi-process-safe

Low priority todo

• transaction support that handles multiple key-space at a time.
• thread-safe support
• non db lock multi-process-safe support

Examples

Example DbMapDbString:

use siamesedb::{DbMapDbString, DbXxx, DbXxxBase, DbXxxObjectSafe};

fn main() -> std::io::Result<()> {
    let db_name = "target/tmp/doc-test1.siamesedb";
    // remove database
    let _ = std::fs::remove_dir_all(db_name);
    // create or open database
    let db = siamesedb::open_file(db_name)?;
    // create or get db map
    let mut db_map = db.db_map_string("some_map1")?;
    //
    let r = db_map.get_string("key1")?;
    assert_eq!(r, None);
    db_map.put_string("key1", "value1")?;
    let r = db_map.get_string("key1")?;
    assert_eq!(r, Some("value1".into()));
    db_map.sync_data()?;
    Ok(())
}

Example DbMapDbInt:

use siamesedb::{DbMapDbInt, DbXxx, DbXxxBase, DbXxxObjectSafe};

fn main() -> std::io::Result<()> {
    let db_name = "target/tmp/doc-test2.siamesedb";
    // remove database
    let _ = std::fs::remove_dir_all(db_name);
    // create or open database
    let db = siamesedb::open_file(db_name)?;
    let mut db_map = db.db_map_int("some_list1")?;
    let r = db_map.get_string(&120)?;
    assert_eq!(r, None);
    db_map.put_string(&120, "value120")?;
    let r = db_map.get_string(&120)?;
    assert_eq!(r, Some("value120".to_string()));
    db_map.sync_data()?;
    Ok(())
}

Example Iterator:

use siamesedb::{DbMapDbString, DbMap, DbXxx, DbXxxBase, DbXxxObjectSafe};

fn main() -> std::io::Result<()> {
    let db_name = "target/tmp/doc-test3.siamesedb";
    // remove database
    let _ = std::fs::remove_dir_all(db_name);
    // create or open database
    let db = siamesedb::open_file(db_name)?;
    // create or get db map
    let mut db_map = db.db_map_string("some_map1")?;
    //
    // insert
    db_map.put_string("key01", "value1").unwrap();
    db_map.put_string("key02", "value2").unwrap();
    db_map.put_string("key03", "value3").unwrap();
    //
    // iterator
    let mut iter = db_map.iter();
    assert_eq!(iter.next(), Some(("key01".into(), "value1".into())));
    assert_eq!(iter.next(), Some(("key02".into(), "value2".into())));
    assert_eq!(iter.next(), Some(("key03".into(), "value3".into())));
    assert_eq!(iter.next(), None);
    //
    db_map.sync_data()?;
    Ok(())
}

Re-exports

pub use filedb::DbBytes;

pub use filedb::DbInt;

pub use filedb::DbString;

pub use filedb::DbXxxIter;

pub use filedb::DbXxxIterMut;

Modules

filedb

memdb

Traits

DbMap

key-value db map store interface.

DbMapDbBytes

key-value map store interface. the key type is Vec<u8>.

DbMapDbInt

key-value map store interface. the key type is u64.

DbMapDbString

key-value map store interface. the key type is String.

DbMapKeyType

key type

DbXxx

generic key-value map store interface. the key type is KT.

DbXxxBase

base interface for generic key-value map store interface. this is not include KT

DbXxxObjectSafe

generic key-value map store interface. the key type is KT. this is only object safe.

HashValue

hash value for htx

Functions

open_file

Open the file db. This data is stored in file.

open_memory

Open the memory db. This data is not stored in file.