Husky

Husky 是围绕 sled 的抽象，允许创建与迭代器类似 API 的视图。其目标是使缓存和索引更容易。

以下是功能列表。有关示例，请参阅文档。

部分

• 添加依赖
• 打开数据库
• 打开树
• 视图
  • 是否为空
  • 键存在
  • 获取
  • 较小和较大
  • 范围
  • 迭代
  • 第一和最后一个
• 更改
  • 插入
  • 删除
  • 清除
  • 自动递增
• 操作
  • 映射
  • 转换
  • 索引
  • 链
  • 压缩
  • 筛选
  • 还原
  • 插入器
  • 管道
• 存储和加载
• 监视

入门

添加依赖

使用 husky 与 rkyv

husky = "0.2"

使用 husky 与 serde

husky = { version = "0.2", default-features = false, features = ["serde"] }

打开数据库

使用以下方式打开数据库

let db = husky::open("db_name").unwrap();

或

let db = husky::open_temp().unwrap();

打开树

您可以在数据库中打开单个条目

let single = db.open_single("key").unwrap();

磁盘上的键值树

let tree = db.open_tree("name").unwrap();

或临时键值树

let temp = db.open_temp();

查看

通过 View 特性可以查询树中的条目。

use husky::View;

检查视图是否为空

assert_eq!(tree.is_empty(), Some(false));

检查键是否存在

assert_eq!(tree.contains_key(1),  Ok(true));
assert_eq!(tree.contains_key(2),  Ok(true));

获取单个值

assert_eq!(tree.get(1),  Ok(Some("first value")));
assert_eq!(tree.get(2),  Ok(Some("last  value")));

获取前后条目

assert_eq!(tree.get_lt(2), Ok(Some("first value"));
assert_eq!(tree.get_gt(1), Ok(Some("last  value"));

获取条目范围

let mut range = tree.range(..).unwrap();
assert_eq!(range.next(),  Ok(Some((1, "first value"))));
assert_eq!(range.next(),  Ok(Some((2, "last  value"))));

获取所有条目

let mut iter = tree.iter();
assert_eq!(iter.next(),  Ok(Some((1, "first value"))));
assert_eq!(iter.next(),  Ok(Some((2, "last  value"))));

获取第一和最后一个条目

assert_eq!(tree.first(),  Ok(Some((1, "first value"))));
assert_eq!(tree.last() ,  Ok(Some((2, "last  value"))));

更改

通过 Change 特性可以操作树中的条目

use husky::Change;

插入条目

let previous = tree.insert("key", "value").unwrap();

删除条目

let previous = tree.remove("key").unwrap();

清除所有条目

tree.clear().unwrap();

使用自动递增插入

如果键类型实现了 AutoInc 特性，则可以推送值。默认情况下，所有无符号整数和 usize 都实现了该特性。

tree.push("value").unwrap()

操作

通过 Operate 特性可以创建新视图。它们是原始视图的懒加载包装，但您可以存储其结果。

use husky::Operate;

映射条目

let map = tree.map(|key, value| "new_value");

转换条目

let transform = tree.map(|key, value| vec![
  ("first  key", "first  value"),
  ("second key", "second value")
]);

重新索引条目

let index = tree.map(|key, value| vec![
  "first  key",
  "second key"
]);

链两个视图

let chain = tree.chain(&other_tree);

压缩两个视图

let zip = tree.zip(&other_tree);
let (a, b) = zip.unzip();

筛选条目

let filter = tree.filter(|key, value| false);
let filter = tree.filter_map(|key, value| Some(value));

减少插入

let reducer = tree.reducer(|value, add| value.unwrap_or(0) + add);

筛选并减少插入

let reducer = tree.filter_reducer(|value, add| value.map(|v| v + add));

解析插入

let inserter = tree.inserter(|insert| insert);

筛选并解析插入

let inserter = tree.filter_inserter(|insert| Some(insert));

将更改管道到另一个树

tree.pipe(&other_tree);

注意，转换和索引还将值类型更改为向量，因为可能会发生覆盖。要进一步操作转换或索引，必须存储或加载它们，因为它们需要一个键映射。

存储

您可以通过 Store 特性在数据库中存储视图

use husky::Store;
let stored = tree.store("tree name").unwrap();

或通过 Load 特性在内存中加载它

use husky::Load;
let loaded = tree.load().unwrap();

一旦加载或存储了树，其结果将进行缓存，并且每次操作都会启动新的线程以传播原始树的事件。

监听

Watch 特性为您提供了对监听视图事件的 BusReader 的访问。

use husky::Watch.
let reader = tree.watch();

获取原始树数据库的函数。

let db = tree.db();

以及同步更改的方法。

let sync = tree.sync();
assert_eq!(sync.incoming(), 0);
assert_eq!(sync.is_sync(), true);
sync.wait();
tree.wait();