2022-06-02 14:58:00 +00:00
|
|
|
use core::ops::Bound;
|
|
|
|
|
2022-06-02 16:11:32 +00:00
|
|
|
use std::cell::Cell;
|
2022-06-02 12:59:26 +00:00
|
|
|
use std::collections::HashMap;
|
|
|
|
use std::sync::{Arc, RwLock};
|
|
|
|
|
|
|
|
use sled::transaction::{
|
2022-06-02 13:25:24 +00:00
|
|
|
ConflictableTransactionError, TransactionError, Transactional, TransactionalTree,
|
|
|
|
UnabortableTransactionError,
|
2022-06-02 12:59:26 +00:00
|
|
|
};
|
|
|
|
|
2022-06-02 16:11:32 +00:00
|
|
|
use crate::{
|
2022-06-03 08:44:54 +00:00
|
|
|
Db, Error, Exporter, IDb, ITx, ITxFn, IValue, Result, TxError, TxFnResult, TxResult, Value,
|
|
|
|
ValueIter,
|
2022-06-02 16:11:32 +00:00
|
|
|
};
|
2022-06-02 12:59:26 +00:00
|
|
|
|
2022-06-02 15:01:04 +00:00
|
|
|
pub use sled;
|
|
|
|
|
2022-06-03 08:44:54 +00:00
|
|
|
// -- err
|
|
|
|
|
2022-06-02 12:59:26 +00:00
|
|
|
impl From<sled::Error> for Error {
|
|
|
|
fn from(e: sled::Error) -> Error {
|
|
|
|
Error(format!("{}", e).into())
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-06-03 08:44:54 +00:00
|
|
|
// -- val
|
|
|
|
|
|
|
|
impl<'a> IValue<'a> for sled::IVec {
|
2022-06-03 09:14:24 +00:00
|
|
|
fn take_maybe(&mut self) -> Vec<u8> {
|
2022-06-03 08:44:54 +00:00
|
|
|
self.to_vec()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl<'a> From<Value<'a>> for sled::IVec {
|
|
|
|
fn from(v: Value<'a>) -> sled::IVec {
|
|
|
|
sled::IVec::from(v.into_vec())
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl<'a> From<sled::IVec> for Value<'a> {
|
|
|
|
fn from(v: sled::IVec) -> Value<'a> {
|
|
|
|
Value(Box::new(v))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// -- db
|
|
|
|
|
2022-06-02 12:59:26 +00:00
|
|
|
pub struct SledDb {
|
|
|
|
db: sled::Db,
|
|
|
|
trees: RwLock<(Vec<sled::Tree>, HashMap<String, usize>)>,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl SledDb {
|
2022-06-03 09:14:24 +00:00
|
|
|
pub fn init(db: sled::Db) -> Db {
|
2022-06-02 12:59:26 +00:00
|
|
|
let s = Self {
|
|
|
|
db,
|
|
|
|
trees: RwLock::new((Vec::new(), HashMap::new())),
|
|
|
|
};
|
|
|
|
Db(Arc::new(s))
|
|
|
|
}
|
|
|
|
|
|
|
|
fn get_tree(&self, i: usize) -> Result<sled::Tree> {
|
|
|
|
self.trees
|
|
|
|
.read()
|
|
|
|
.unwrap()
|
|
|
|
.0
|
|
|
|
.get(i)
|
|
|
|
.cloned()
|
2022-06-03 09:14:24 +00:00
|
|
|
.ok_or_else(|| Error("invalid tree id".into()))
|
2022-06-02 12:59:26 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl IDb for SledDb {
|
2022-06-02 14:58:00 +00:00
|
|
|
fn open_tree(&self, name: &str) -> Result<usize> {
|
2022-06-02 12:59:26 +00:00
|
|
|
let mut trees = self.trees.write().unwrap();
|
|
|
|
if let Some(i) = trees.1.get(name) {
|
|
|
|
Ok(*i)
|
|
|
|
} else {
|
|
|
|
let tree = self.db.open_tree(name)?;
|
|
|
|
let i = trees.0.len();
|
|
|
|
trees.0.push(tree);
|
|
|
|
trees.1.insert(name.to_string(), i);
|
|
|
|
Ok(i)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-06-02 17:58:47 +00:00
|
|
|
// ----
|
|
|
|
|
2022-06-03 09:14:24 +00:00
|
|
|
fn get(&self, tree: usize, key: &[u8]) -> Result<Option<Value<'_>>> {
|
2022-06-02 12:59:26 +00:00
|
|
|
let tree = self.get_tree(tree)?;
|
2022-06-03 08:44:54 +00:00
|
|
|
Ok(tree.get(key)?.map(From::from))
|
2022-06-02 12:59:26 +00:00
|
|
|
}
|
2022-06-02 13:25:24 +00:00
|
|
|
|
2022-06-02 14:58:00 +00:00
|
|
|
fn remove(&self, tree: usize, key: &[u8]) -> Result<bool> {
|
|
|
|
let tree = self.get_tree(tree)?;
|
|
|
|
Ok(tree.remove(key)?.is_some())
|
|
|
|
}
|
|
|
|
|
|
|
|
fn len(&self, tree: usize) -> Result<usize> {
|
|
|
|
let tree = self.get_tree(tree)?;
|
|
|
|
Ok(tree.len())
|
|
|
|
}
|
|
|
|
|
|
|
|
fn insert(&self, tree: usize, key: &[u8], value: &[u8]) -> Result<()> {
|
2022-06-02 12:59:26 +00:00
|
|
|
let tree = self.get_tree(tree)?;
|
|
|
|
tree.insert(key, value)?;
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
2022-06-03 09:14:24 +00:00
|
|
|
fn iter(&self, tree: usize) -> Result<ValueIter<'_>> {
|
2022-06-02 14:58:00 +00:00
|
|
|
let tree = self.get_tree(tree)?;
|
|
|
|
Ok(Box::new(tree.iter().map(|v| {
|
2022-06-03 08:44:54 +00:00
|
|
|
v.map(|(x, y)| (x.into(), y.into())).map_err(Into::into)
|
2022-06-02 14:58:00 +00:00
|
|
|
})))
|
|
|
|
}
|
|
|
|
|
2022-06-03 09:14:24 +00:00
|
|
|
fn iter_rev(&self, tree: usize) -> Result<ValueIter<'_>> {
|
2022-06-02 14:58:00 +00:00
|
|
|
let tree = self.get_tree(tree)?;
|
|
|
|
Ok(Box::new(tree.iter().rev().map(|v| {
|
2022-06-03 08:44:54 +00:00
|
|
|
v.map(|(x, y)| (x.into(), y.into())).map_err(Into::into)
|
2022-06-02 14:58:00 +00:00
|
|
|
})))
|
|
|
|
}
|
|
|
|
|
2022-06-03 09:14:24 +00:00
|
|
|
fn range<'r>(
|
|
|
|
&self,
|
2022-06-02 13:25:24 +00:00
|
|
|
tree: usize,
|
2022-06-02 14:58:00 +00:00
|
|
|
low: Bound<&'r [u8]>,
|
|
|
|
high: Bound<&'r [u8]>,
|
2022-06-03 09:14:24 +00:00
|
|
|
) -> Result<ValueIter<'_>> {
|
2022-06-02 13:25:24 +00:00
|
|
|
let tree = self.get_tree(tree)?;
|
2022-06-02 14:58:00 +00:00
|
|
|
Ok(Box::new(tree.range::<&'r [u8], _>((low, high)).map(|v| {
|
2022-06-03 08:44:54 +00:00
|
|
|
v.map(|(x, y)| (x.into(), y.into())).map_err(Into::into)
|
2022-06-02 14:58:00 +00:00
|
|
|
})))
|
|
|
|
}
|
2022-06-03 09:14:24 +00:00
|
|
|
fn range_rev<'r>(
|
|
|
|
&self,
|
2022-06-02 14:58:00 +00:00
|
|
|
tree: usize,
|
|
|
|
low: Bound<&'r [u8]>,
|
|
|
|
high: Bound<&'r [u8]>,
|
2022-06-03 09:14:24 +00:00
|
|
|
) -> Result<ValueIter<'_>> {
|
2022-06-02 14:58:00 +00:00
|
|
|
let tree = self.get_tree(tree)?;
|
|
|
|
Ok(Box::new(tree.range::<&'r [u8], _>((low, high)).rev().map(
|
2022-06-03 08:44:54 +00:00
|
|
|
|v| v.map(|(x, y)| (x.into(), y.into())).map_err(Into::into),
|
2022-06-02 14:58:00 +00:00
|
|
|
)))
|
2022-06-02 13:25:24 +00:00
|
|
|
}
|
|
|
|
|
2022-06-02 17:58:47 +00:00
|
|
|
// ----
|
|
|
|
|
2022-06-02 12:59:26 +00:00
|
|
|
fn transaction(&self, f: &dyn ITxFn) -> TxResult<(), ()> {
|
|
|
|
let trees = self.trees.read().unwrap();
|
|
|
|
let res = trees.0.transaction(|txtrees| {
|
|
|
|
let tx = SledTx {
|
|
|
|
trees: txtrees,
|
2022-06-02 16:11:32 +00:00
|
|
|
err: Cell::new(None),
|
2022-06-02 12:59:26 +00:00
|
|
|
};
|
|
|
|
match f.try_on(&tx) {
|
|
|
|
TxFnResult::Ok => {
|
|
|
|
assert!(tx.err.into_inner().is_none());
|
|
|
|
Ok(())
|
|
|
|
}
|
2022-06-02 13:25:24 +00:00
|
|
|
TxFnResult::Abort => {
|
|
|
|
assert!(tx.err.into_inner().is_none());
|
|
|
|
Err(ConflictableTransactionError::Abort(()))
|
|
|
|
}
|
2022-06-02 17:58:47 +00:00
|
|
|
TxFnResult::DbErr => {
|
|
|
|
let e = tx.err.into_inner().expect("No DB error");
|
|
|
|
Err(e.into())
|
2022-06-02 12:59:26 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
|
|
match res {
|
|
|
|
Ok(()) => Ok(()),
|
|
|
|
Err(TransactionError::Abort(())) => Err(TxError::Abort(())),
|
|
|
|
Err(TransactionError::Storage(s)) => Err(TxError::Db(s.into())),
|
|
|
|
}
|
|
|
|
}
|
2022-06-02 17:58:47 +00:00
|
|
|
|
|
|
|
// ----
|
|
|
|
|
2022-06-03 09:14:24 +00:00
|
|
|
fn export(&self) -> Result<Exporter<'_>> {
|
2022-06-02 17:58:47 +00:00
|
|
|
let mut trees = vec![];
|
|
|
|
for name in self.db.tree_names() {
|
|
|
|
let name = std::str::from_utf8(&name)
|
|
|
|
.map_err(|e| Error(format!("{}", e).into()))?
|
|
|
|
.to_string();
|
|
|
|
let tree = self.open_tree(&name)?;
|
|
|
|
let tree = self.trees.read().unwrap().0.get(tree).unwrap().clone();
|
|
|
|
trees.push((name, tree));
|
|
|
|
}
|
2022-06-03 09:14:24 +00:00
|
|
|
let trees_exporter: Exporter<'_> = Box::new(trees.into_iter().map(|(name, tree)| {
|
|
|
|
let iter: ValueIter<'_> = Box::new(
|
2022-06-03 08:44:54 +00:00
|
|
|
tree.iter()
|
|
|
|
.map(|v| v.map(|(x, y)| (x.into(), y.into())).map_err(Into::into)),
|
|
|
|
);
|
2022-06-03 09:14:24 +00:00
|
|
|
Ok((name, iter))
|
2022-06-02 17:58:47 +00:00
|
|
|
}));
|
|
|
|
Ok(trees_exporter)
|
|
|
|
}
|
|
|
|
|
2022-06-03 09:14:24 +00:00
|
|
|
fn import(&self, ex: Exporter<'_>) -> Result<()> {
|
2022-06-02 17:58:47 +00:00
|
|
|
for ex_tree in ex {
|
|
|
|
let (name, data) = ex_tree?;
|
|
|
|
|
|
|
|
let tree = self.open_tree(&name)?;
|
|
|
|
let tree = self.trees.read().unwrap().0.get(tree).unwrap().clone();
|
|
|
|
if !tree.is_empty() {
|
|
|
|
return Err(Error(format!("tree {} already contains data", name).into()));
|
|
|
|
}
|
|
|
|
|
|
|
|
let mut i = 0;
|
|
|
|
for item in data {
|
|
|
|
let (k, v) = item?;
|
2022-06-03 08:44:54 +00:00
|
|
|
tree.insert(k, v)?;
|
2022-06-02 17:58:47 +00:00
|
|
|
i += 1;
|
|
|
|
if i % 1000 == 0 {
|
|
|
|
println!("{}: imported {}", name, i);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
println!("{}: finished importing, {} items", name, i);
|
|
|
|
}
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
|
|
|
// ----
|
2022-06-02 12:59:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// ----
|
|
|
|
|
|
|
|
struct SledTx<'a> {
|
|
|
|
trees: &'a [TransactionalTree],
|
2022-06-02 16:11:32 +00:00
|
|
|
err: Cell<Option<UnabortableTransactionError>>,
|
2022-06-02 12:59:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
impl<'a> SledTx<'a> {
|
2022-06-02 15:38:30 +00:00
|
|
|
fn get_tree(&self, i: usize) -> Result<&TransactionalTree> {
|
2022-06-03 09:14:24 +00:00
|
|
|
self.trees.get(i).ok_or_else(|| {
|
|
|
|
Error(
|
|
|
|
"invalid tree id (it might have been openned after the transaction started)".into(),
|
|
|
|
)
|
|
|
|
})
|
2022-06-02 15:38:30 +00:00
|
|
|
}
|
|
|
|
|
2022-06-02 12:59:26 +00:00
|
|
|
fn save_error<R>(&self, v: std::result::Result<R, UnabortableTransactionError>) -> Result<R> {
|
|
|
|
match v {
|
|
|
|
Ok(x) => Ok(x),
|
|
|
|
Err(e) => {
|
|
|
|
let txt = format!("{}", e);
|
2022-06-02 16:11:32 +00:00
|
|
|
self.err.set(Some(e));
|
2022-06-02 12:59:26 +00:00
|
|
|
Err(Error(txt.into()))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl<'a> ITx<'a> for SledTx<'a> {
|
|
|
|
fn get(&self, tree: usize, key: &[u8]) -> Result<Option<Value<'a>>> {
|
2022-06-02 15:38:30 +00:00
|
|
|
let tree = self.get_tree(tree)?;
|
2022-06-02 12:59:26 +00:00
|
|
|
let tmp = self.save_error(tree.get(key))?;
|
2022-06-03 08:44:54 +00:00
|
|
|
Ok(tmp.map(From::from))
|
2022-06-02 12:59:26 +00:00
|
|
|
}
|
2022-06-02 15:38:30 +00:00
|
|
|
fn len(&self, _tree: usize) -> Result<usize> {
|
|
|
|
unimplemented!(".len() in transaction not supported with Sled backend")
|
|
|
|
}
|
2022-06-02 12:59:26 +00:00
|
|
|
|
2022-06-02 14:58:00 +00:00
|
|
|
fn insert(&self, tree: usize, key: &[u8], value: &[u8]) -> Result<()> {
|
2022-06-02 15:38:30 +00:00
|
|
|
let tree = self.get_tree(tree)?;
|
2022-06-02 12:59:26 +00:00
|
|
|
self.save_error(tree.insert(key, value))?;
|
|
|
|
Ok(())
|
|
|
|
}
|
2022-06-02 14:58:00 +00:00
|
|
|
fn remove(&self, tree: usize, key: &[u8]) -> Result<bool> {
|
2022-06-02 15:38:30 +00:00
|
|
|
let tree = self.get_tree(tree)?;
|
2022-06-02 14:58:00 +00:00
|
|
|
Ok(self.save_error(tree.remove(key))?.is_some())
|
|
|
|
}
|
2022-06-02 15:38:30 +00:00
|
|
|
|
|
|
|
fn iter(&self, _tree: usize) -> Result<ValueIter<'a>> {
|
|
|
|
unimplemented!("Iterators in transactions not supported with Sled backend");
|
|
|
|
}
|
|
|
|
fn iter_rev(&self, _tree: usize) -> Result<ValueIter<'a>> {
|
|
|
|
unimplemented!("Iterators in transactions not supported with Sled backend");
|
|
|
|
}
|
|
|
|
|
|
|
|
fn range<'r>(
|
|
|
|
&self,
|
|
|
|
_tree: usize,
|
|
|
|
_low: Bound<&'r [u8]>,
|
|
|
|
_high: Bound<&'r [u8]>,
|
|
|
|
) -> Result<ValueIter<'a>> {
|
|
|
|
unimplemented!("Iterators in transactions not supported with Sled backend");
|
|
|
|
}
|
|
|
|
fn range_rev<'r>(
|
|
|
|
&self,
|
|
|
|
_tree: usize,
|
|
|
|
_low: Bound<&'r [u8]>,
|
|
|
|
_high: Bound<&'r [u8]>,
|
|
|
|
) -> Result<ValueIter<'a>> {
|
|
|
|
unimplemented!("Iterators in transactions not supported with Sled backend");
|
|
|
|
}
|
2022-06-02 12:59:26 +00:00
|
|
|
}
|