1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

#![deny(missing_docs)]

//! `kv` is a simple way to embed a key/value store in Rust applications. It is built using
//! [sled](https://docs.rs/sled) and aims to be as lightweight as possible while still
//! providing a nice high level interface.
//!
//! ## Getting started
//!
//! ```rust
//! use kv::*;
//!
//! #[derive(serde::Serialize, serde::Deserialize, PartialEq)]
//! struct SomeType {
//!     a: i32,
//!     b: i32
//! }
//!
//! fn run() -> Result<(), Error> {
//!     // Configure the database
//!     let mut cfg = Config::new("./test/example1");
//!
//!     // Open the key/value store
//!     let store = Store::new(cfg)?;
//!
//!     // A Bucket provides typed access to a section of the key/value store
//!     let test = store.bucket::<Raw, Raw>(Some("test"))?;
//!
//!     // Set testing = 123
//!     test.set(b"test", b"123")?;
//!     assert!(test.get(b"test").unwrap().unwrap() == "123");
//!     assert!(test.get(b"something else").unwrap() == None);
//!
//!     // Integer keys
//!     let aaa = store.bucket::<Integer, String>(Some("aaa"))?;
//!     aaa.set(1, "Testing");
//!
//!     #[cfg(feature = "json-value")]
//!     {
//!         // Using a Json encoded type is easy, thanks to Serde
//!         let bucket = store.bucket::<&str, Json<SomeType>>(None)?;
//!
//!         let x = SomeType {a: 1, b: 2};
//!         bucket.set("example", Json(x))?;
//!
//!         let x: Json<SomeType> = bucket.get("example")?.unwrap();
//!
//!         for item in bucket.iter() {
//!             let item = item?;
//!             let key: String = item.key()?;
//!             let value = item.value::<Json<SomeType>>()?;
//!             println!("key: {}, value: {}", key, value);
//!         }
//!
//!         // A transaction
//!         bucket.transaction(|txn| {
//!             txn.set("x", Json(SomeType {a: 1, b: 2}))?;
//!             txn.set("y", Json(SomeType {a: 3, b: 4}))?;
//!             txn.set("z", Json(SomeType {a: 5, b: 6}))?;
//!
//!             Ok(())
//!         })?;
//!     }
//!     Ok(())
//! }
//! #
//! # fn main() {
//! #     run().unwrap();
//! # }
//! ```

mod bucket;
mod codec;
mod config;
mod error;
mod store;
mod transaction;
mod types;

pub use bucket::{Batch, Bucket, Event, Item, Iter, Watch};
pub use codec::*;
pub use config::Config;
pub use error::Error;
pub use store::Store;
pub use transaction::{Transaction, TransactionError};
pub use types::{Integer, Key, Raw, Value};

/// Abort a transaction
pub fn abort<E>(x: E) -> TransactionError<E> {
    TransactionError::Abort(x)
}

#[cfg(test)]
mod tests;