diff --git a/docs/quick_start.md b/docs/quick_start.md
new file mode 100644
index 0000000..90b0cea
--- /dev/null
+++ b/docs/quick_start.md
@@ -0,0 +1 @@
+# NutsDB 快速开始
\ No newline at end of file
diff --git a/docs/tutorial/kv.md b/docs/tutorial/kv.md
new file mode 100644
index 0000000..d386a6e
--- /dev/null
+++ b/docs/tutorial/kv.md
@@ -0,0 +1,416 @@
+# 使用键值对
+
+## 基本操作
+
+将key-value键值对保存在一个bucket, 你可以使用 `tx.Put` 这个方法:
+
+### 添加数据
+
+```go
+
+if err := db.Update(
+ func(tx *nutsdb.Tx) error {
+ key := []byte("name1")
+ val := []byte("val1")
+ bucket := "bucket1"
+ if err := tx.Put(bucket, key, val, 0); err != nil {
+ return err
+ }
+ return nil
+}); err != nil {
+ log.Fatal(err)
+}
+
+```
+
+### 更新数据
+
+上面的代码执行之后key为"name1"和value值"val1"被保存在命名为bucket1的bucket里面。
+
+如果你要做更新操作，你可以仍然用`tx.Put`方法去执行，比如下面的例子把value的值改成"val1-modify"：
+
+```go
+if err := db.Update(
+ func(tx *nutsdb.Tx) error {
+ key := []byte("name1")
+ val := []byte("val1-modify") // 更新值
+ bucket := "bucket1"
+ if err := tx.Put(bucket, key, val, 0); err != nil {
+ return err
+ }
+ return nil
+}); err != nil {
+ log.Fatal(err)
+}
+
+```
+
+### 获取数据
+
+获取值可以用`tx.Get` 这个方法:
+
+```go
+if err := db.View(
+func(tx *nutsdb.Tx) error {
+ key := []byte("name1")
+ bucket := "bucket1"
+ if value, err := tx.Get(bucket, key); err != nil {
+ return err
+ } else {
+ fmt.Println(string(value)) // "val1-modify"
+ }
+ return nil
+}); err != nil {
+ log.Println(err)
+}
+```
+
+### 删除数据
+
+删除使用`tx.Delete()` 方法：
+
+```go
+if err := db.Update(
+ func(tx *nutsdb.Tx) error {
+ key := []byte("name1")
+ bucket := "bucket1"
+ if err := tx.Delete(bucket, key); err != nil {
+ return err
+ }
+ return nil
+}); err != nil {
+ log.Fatal(err)
+}
+```
+
+### 对值的位操作
+
+#### 使用`tx.GetBit()`方法获取某一键所对应的值在某一偏移量上的值。当对应的键存在时，返回参数中偏移量所对应位置的上的值，当偏移量超出原有的数据范围时，将返回0且不报错；当对应的键不存在时，将报错提示键不存在。
+
+```go
+if err := db.View(func(tx *nutsdb.Tx) error {
+ bucket := "bucket"
+ key := []byte("key")
+ offset := 2
+ bit, err := tx.GetBit(bucket, key, offset)
+ if err != nil {
+ return err
+ }
+ log.Println("get bit:", bit)
+ return nil
+}); err != nil {
+ log.Println(err)
+}
+```
+
+#### 使用`tx.SetBit()`方法添加某一键所对应的值在某一偏移量上的值。当对应的键存在时，将会修改偏移量所对应的位上的值；当对应的键不存在或者偏移量超出原有的数据范围时，将会对原有值进行扩容直到能够在偏移量对应位置上修改。除偏移量对应位置之外，自动扩容产生的位的值均为0。
+
+```go
+if err := db.Update(func(tx *nutsdb.Tx) error {
+ bucket := "bucket"
+ key := []byte("key")
+ offset := 2
+ bit := 1
+ return tx.SetBit(bucket, key, offset, bit)
+}); err != nil {
+ log.Println(err)
+}
+```
+
+### 对值的自增和自减操作
+
+在对值进行自增和自减操作时需要键存在，否则将报错提示键不存在。当值的自增和自减结果将超出`int64`的范围时，将使用基于字符串的大数计算，所以不必担心值的范围过大。
+
+* 使用`tx.Incr()`方法让某一键所对应的值自增1
+
+```go
+if err := db.Update(func(tx *nutsdb.Tx) error {
+ bucket := "bucket"
+ key := []byte("key")
+ return tx.Incr(bucket, key)
+}); err != nil {
+ log.Println(err)
+}
+```
+
+* 使用`tx.IncrBy()`方法让某一键所对应的值自增指定的值
+
+```go
+if err := db.Update(func(tx *nutsdb.Tx) error {
+ bucket := "bucket"
+ key := []byte("key")
+ return tx.IncrBy(bucket, key, 10)
+}); err != nil {
+ log.Println(err)
+}
+```
+
+* 使用`tx.Decr()`方法让某一键所对应的值自减1
+
+```go
+if err := db.Update(func(tx *nutsdb.Tx) error {
+ bucket := "bucket"
+ key := []byte("key")
+ return tx.Decr(bucket, key)
+}); err != nil {
+ log.Println(err)
+}
+```
+
+* 使用`tx.DecrBy()`方法让某一键所对应的值自减指定的值
+
+```go
+if err := db.Update(func(tx *nutsdb.Tx) error {
+ bucket := "bucket"
+ key := []byte("key")
+ return tx.DecrBy(bucket, key, 10)
+}); err != nil {
+ log.Println(err)
+}
+```
+
+### 对值的连续多次Set和Get
+
+* 使用`tx.MSet()`方法连续多次设置键值对。当使用`tx.MSet()`需要以`...[]byte`类型传入若干个键值对。此处要求参数的总数为偶数个，设i为从0开始的偶数，则第i个参数和第i+1个参数将分别成为一个键值对的键和值。
+
+```go
+if err := db.Update(func(tx *nutsdb.Tx) error {
+ bucekt := "bucket"
+ args := [][]byte{
+ []byte("1"), []byte("2"), []byte("3"), []byte("4"),
+ }
+ return tx.MSet(bucket, nutsdb.Persistent, args...)
+}); err != nil {
+ log.Println(err)
+}
+```
+
+* 使用`tx.MGet()`方法连续多次取值。当使用`tx.MGet()`需要以`...[]byte`类型传入若干个键，若其中任何一个键不存在都会返回`key not found`错误。返回值是一个切片，长度与传入的参数相同，并且根据切片索引一一对应。
+
+```go
+if err := db.View(func(tx *nutsdb.Tx) error {
+ bucket := "bucket"
+ key := [][]byte{
+ []byte("1"), []byte("2"), []byte("3"), []byte("4"),
+ }
+ values, err := tx.MGet(bucket, key...)
+ if err != nil {
+ return err
+ }
+ for i, value := range values {
+ log.Printf("get value by MGet, the %d value is '%s'", i, string(value))
+ }
+ return nil
+}); err != nil {
+ log.Println(err)
+}
+```
+
+### 对值的增补操作
+
+* 使用`tx.Append()`方法对值进行增补。
+
+```go
+if err := db.Update(func(tx *nutsdb.Tx) error {
+ bucket := "bucket"
+ key := "key"
+ appendage := "appendage"
+ return tx.Append(bucket, []byte(key), []byte(appendage))
+}); err != nil {
+ log.Println(err)
+}
+```
+
+### 获取值的一部分
+
+* 使用`tx.GetRange()`方法可以根据给定的索引获取值的一部分。通过两个`int`类型的参数确定一个闭区间，返回闭区间所对应部分的值。
+
+```go
+if err := db.View(func(tx *nutsdb.Tx) error {
+ bucket := "bucket"
+ key := "key"
+ start := 0
+ end := 2
+ value, err := tx.GetRange(bucket, []byte(key), start, end)
+ if err != nil {
+ return err
+ }
+ log.Printf("got value: '%s'", string(value))
+ return nil
+}); err != nil {
+ log.Println(err)
+}
+```
+
+### 使用TTL
+
+NusDB支持TTL(存活时间)的功能，可以对指定的bucket里的key过期时间的设置。使用`tx.Put`这个方法的使用`ttl`参数就可以了。
+如果设置 ttl = 0 或者 Persistent, 这个key就会永久存在。下面例子中ttl设置成 60 , 60s之后key就会过期，在查询的时候将不会被搜到。
+
+```go
+if err := db.Update(
+ func(tx *nutsdb.Tx) error {
+ key := []byte("name1")
+ val := []byte("val1")
+ bucket := "bucket1"
+
+ // 如果设置 ttl = 0 or Persistent, 这个key就会永久不删除
+ // 这边 ttl = 60 , 60s之后就会过期。
+ if err := tx.Put(bucket, key, val, 60); err != nil {
+ return err
+ }
+ return nil
+}); err != nil {
+ log.Fatal(err)
+}
+```
+### 对keys的扫描操作
+
+key在一个bucket里面按照byte-sorted有序排序的，所以对于keys的扫描操作，在NutsDB里是很高效的。
+
+
+#### 前缀扫描
+
+对于前缀的扫描，我们可以用`PrefixScan` 方法, 使用参数 `offSet`和`limitNum` 来限制返回的结果的数量，比方下面例子限制100个entries:
+
+```go
+
+if err := db.View(
+ func(tx *nutsdb.Tx) error {
+ prefix := []byte("user_")
+ bucket := "user_list"
+ // 从offset=0开始 ，限制 100 entries 返回
+ if entries, err := tx.PrefixScan(bucket, prefix, 0, 100); err != nil {
+ return err
+ } else {
+ for _, entry := range entries {
+ fmt.Println(string(entry.Key), string(entry.Value))
+ }
+ }
+ return nil
+ }); err != nil {
+ log.Fatal(err)
+}
+
+```
+
+#### 前缀后的正则扫描
+
+对于前缀后的扫描，可以通过正则表达式对键的第二部分进行搜索来遍历一个键前缀，我们可以使用`PrefixSearchScan`方法，用参数`reg`来编写正则表达式，使用参数`offsetNum`、`limitNum` 来约束返回的条目的数量:
+
+```go
+
+if err := db.View(
+ func(tx *nutsdb.Tx) error {
+ prefix := []byte("user_") // 定义前缀
+ reg := "99" // 定义正则表达式
+ bucket := "user_list"
+ // 从offset=25开始，限制 100 entries 返回
+ if entries, _, err := tx.PrefixSearchScan(bucket, prefix, reg, 25, 100); err != nil {
+ return err
+ } else {
+ for _, entry := range entries {
+ fmt.Println(string(entry.Key), string(entry.Value))
+ }
+ }
+ return nil
+ }); err != nil {
+ log.Fatal(err)
+}
+```
+
+#### 范围扫描
+
+对于范围的扫描，我们可以用 `RangeScan` 方法。
+
+例子：
+
+```go
+if err := db.View(
+ func(tx *nutsdb.Tx) error {
+ // 假设用户key从 user_0000000 to user_9999999.
+ // 执行区间扫描类似这样一个start和end作为主要参数.
+ start := []byte("user_0010001")
+ end := []byte("user_0010010")
+ bucket := "user_list"
+ if entries, err := tx.RangeScan(bucket, start, end); err != nil {
+ return err
+ } else {
+ for _, entry := range entries {
+ fmt.Println(string(entry.Key), string(entry.Value))
+ }
+ }
+ return nil
+ }); err != nil {
+ log.Fatal(err)
+}
+```
+### 获取全部的key和value
+
+对于获取一个bucket的所有key和value，可以使用`GetAll`方法。
+
+例子：
+
+```go
+if err := db.View(
+ func(tx *nutsdb.Tx) error {
+ bucket := "user_list"
+ entries, err := tx.GetAll(bucket)
+ if err != nil {
+ return err
+ }
+
+ for _, entry := range entries {
+ fmt.Println(string(entry.Key),string(entry.Value))
+ }
+
+ return nil
+ }); err != nil {
+ log.Println(err)
+}
+```
+
+### 迭代器
+
+主要是迭代器的选项参数`Reverse`的值来决定正向还是反向迭代器, 当前版本还不支持HintBPTSparseIdxMode的迭代器
+
+
+#### 正向的迭代器
+
+```go
+tx, err := db.Begin(false)
+iterator := nutsdb.NewIterator(tx, bucket, nutsdb.IteratorOptions{Reverse: false})
+i := 0
+for i < 10 {
+ ok, err := iterator.SetNext()
+ fmt.Println("ok, err", ok, err)
+ fmt.Println("Key: ", string(iterator.Entry().Key))
+ fmt.Println("Value: ", string(iterator.Entry().Value))
+ fmt.Println()
+ i++
+}
+err = tx.Commit()
+if err != nil {
+ panic(err)
+}
+```
+
+#### 反向的迭代器
+
+```go
+tx, err := db.Begin(false)
+iterator := nutsdb.NewIterator(tx, bucket, nutsdb.IteratorOptions{Reverse: true})
+i := 0
+for i < 10 {
+ ok, err := iterator.SetNext()
+ fmt.Println("ok, err", ok, err)
+ fmt.Println("Key: ", string(iterator.Entry().Key))
+ fmt.Println("Value: ", string(iterator.Entry().Value))
+ fmt.Println()
+ i++
+}
+err = tx.Commit()
+if err != nil {
+ panic(err)
+}
+```
diff --git a/docs/tutorial/list.md b/docs/tutorial/list.md
new file mode 100644
index 0000000..aa57020
--- /dev/null
+++ b/docs/tutorial/list.md
@@ -0,0 +1,239 @@
+# 使用列表
+
+## RPush
+
+从指定bucket里面的指定队列key的右边入队一个或者多个元素val。
+
+```go
+if err := db.Update(
+ func(tx *nutsdb.Tx) error {
+ bucket := "bucketForList"
+ key := []byte("myList")
+ val := []byte("val1")
+ return tx.RPush(bucket, key, val)
+ }); err != nil {
+ log.Fatal(err)
+}
+```
+
+## LPush
+
+从指定bucket里面的指定队列key的左边入队一个或者多个元素val。
+
+```go
+if err := db.Update(
+ func(tx *nutsdb.Tx) error {
+ bucket := "bucketForList"
+ key := []byte("myList")
+ val := []byte("val2")
+ return tx.LPush(bucket, key, val)
+ }); err != nil {
+ log.Fatal(err)
+}
+```
+
+## LPop
+
+从指定bucket里面的指定队列key的左边出队一个元素，删除并返回。
+
+```go
+if err := db.Update(
+ func(tx *nutsdb.Tx) error {
+ bucket := "bucketForList"
+ key := []byte("myList")
+ if item, err := tx.LPop(bucket, key); err != nil {
+ return err
+ } else {
+ fmt.Println("LPop item:", string(item))
+ }
+ return nil
+ }); err != nil {
+ log.Fatal(err)
+}
+```
+
+## LPeek
+
+从指定bucket里面的指定队列key的左边出队一个元素返回不删除。
+
+```go
+if err := db.View(
+ func(tx *nutsdb.Tx) error {
+ bucket := "bucketForList"
+ key := []byte("myList")
+ if item, err := tx.LPeek(bucket, key); err != nil {
+ return err
+ } else {
+ fmt.Println("LPeek item:", string(item)) //val11
+ }
+ return nil
+ }); err != nil {
+ log.Fatal(err)
+}
+```
+
+## RPop
+
+从指定bucket里面的指定队列key的右边出队一个元素，删除并返回。
+
+```go
+if err := db.Update(
+ func(tx *nutsdb.Tx) error {
+ bucket := "bucketForList"
+ key := []byte("myList")
+ if item, err := tx.RPop(bucket, key); err != nil {
+ return err
+ } else {
+ fmt.Println("RPop item:", string(item))
+ }
+ return nil
+ }); err != nil {
+ log.Fatal(err)
+}
+```
+
+## RPeek
+
+从指定bucket里面的指定队列key的右边出队一个元素返回不删除。
+
+```go
+if err := db.View(
+ func(tx *nutsdb.Tx) error {
+ bucket := "bucketForList"
+ key := []byte("myList")
+ if item, err := tx.RPeek(bucket, key); err != nil {
+ return err
+ } else {
+ fmt.Println("RPeek item:", string(item))
+ }
+ return nil
+ }); err != nil {
+ log.Fatal(err)
+}
+```
+
+## LRange
+
+返回指定bucket里面的指定队列key列表里指定范围内的元素。 start 和 end 偏移量都是基于0的下标，即list的第一个元素下标是0（list的表头），第二个元素下标是1，以此类推。
+偏移量也可以是负数，表示偏移量是从list尾部开始计数。 例如：-1 表示列表的最后一个元素，-2 是倒数第二个，以此类推。
+
+```go
+if err := db.View(
+ func(tx *nutsdb.Tx) error {
+ bucket := "bucketForList"
+ key := []byte("myList")
+ if items, err := tx.LRange(bucket, key, 0, -1); err != nil {
+ return err
+ } else {
+ //fmt.Println(items)
+ for _, item := range items {
+ fmt.Println(string(item))
+ }
+ }
+ return nil
+ }); err != nil {
+ log.Fatal(err)
+}
+```
+## LRem
+
+注意: 这个方法在 v0.6.0版本开始支持，之前的版本实现和描述有问题。
+
+从指定bucket里面的指定的key的列表里移除前 count 次出现的值为 value 的元素。 这个 count 参数通过下面几种方式影响这个操作：
+
+count > 0: 从头往尾移除值为 value 的元素。
+count < 0: 从尾往头移除值为 value 的元素。
+count = 0: 移除所有值为 value 的元素。
+
+下面的例子count=1：
+
+```go
+if err := db.Update(
+ func(tx *nutsdb.Tx) error {
+ bucket := "bucketForList"
+ key := []byte("myList")
+ return tx.LRem(bucket, key, 1, []byte("val11"))
+ }); err != nil {
+ log.Fatal(err)
+}
+```
+
+## LRemByIndex
+
+注意: 这个方法在 v0.10.0版本开始支持
+
+移除列表中指定位置（单个或多个位置）的元素
+
+```go
+if err := db.Update(
+ func(tx *nutsdb.Tx) error {
+ bucket := "bucketForList"
+ key := []byte("myList")
+ removedNum, err := tx.LRemByIndex(bucket, key, 0, 1)
+ fmt.Printf("removed num %d\n", removedNum)
+ return err
+ }); err != nil {
+ log.Fatal(err)
+}
+```
+
+## LTrim
+
+修剪一个已存在的 list，这样 list 就会只包含指定范围的指定元素。start 和 stop 都是由0开始计数的， 这里的 0 是列表里的第一个元素（表头），1 是第二个元素，以此类推。
+
+例如： LTRIM foobar 0 2 将会对存储在 foobar 的列表进行修剪，只保留列表里的前3个元素。
+
+start 和 end 也可以用负数来表示与表尾的偏移量，比如 -1 表示列表里的最后一个元素， -2 表示倒数第二个，等等。
+
+```go
+if err := db.Update(
+ func(tx *nutsdb.Tx) error {
+ bucket := "bucketForList"
+ key := []byte("myList")
+ return tx.LTrim(bucket, key, 0, 1)
+ }); err != nil {
+ log.Fatal(err)
+}
+```
+
+## LSize
+
+返回指定bucket下指定key列表的size大小
+
+```go
+if err := db.Update(
+ func(tx *nutsdb.Tx) error {
+ bucket := "bucketForList"
+ key := []byte("myList")
+ if size,err := tx.LSize(bucket, key); err != nil {
+ return err
+ } else {
+ fmt.Println("myList size is ",size)
+ }
+ return nil
+ }); err != nil {
+ log.Fatal(err)
+}
+```
+
+## LKeys
+
+查找`List`类型的所有匹配指定模式`pattern`的`key`，类似于Redis命令: [KEYS](https://redis.io/commands/keys/)
+
+注意：模式匹配使用 Go 标准库的`filepath.Match`，部分细节上和redis的行为有区别，比如对于 `[` 的处理。
+
+```go
+if err := db.View(
+ func(tx *nutsdb.Tx) error {
+ var keys []string
+ err := tx.LKeys(bucket, "*", func(key string) bool {
+ keys = append(keys, key)
+ // true: continue, false: break
+ return true
+ })
+ fmt.Printf("keys: %v\n", keys)
+ return err
+ }); err != nil {
+ log.Fatal(err)
+}
+```
diff --git a/docs/tutorial/open_nutsdb.md b/docs/tutorial/open_nutsdb.md
new file mode 100644
index 0000000..2d5bce8
--- /dev/null
+++ b/docs/tutorial/open_nutsdb.md
@@ -0,0 +1,28 @@
+# 开启NutsDB数据库
+
+要打开数据库需要使用` nutsdb.Open()`这个方法。其中用到的选项(options)包括 `Dir` , `EntryIdxMode`和 `SegmentSize`，在调用的时候这些参数必须设置。官方提供了`DefaultOptions`的选项，直接使用`nutsdb.DefaultOptions`即可。当然你也可以根据需要自己定义。
+
+例子：
+
+```go
+package main
+
+import (
+ "log"
+
+ "github.com/nutsdb/nutsdb"
+)
+
+func main() {
+ db, err := nutsdb.Open(
+ nutsdb.DefaultOptions,
+ nutsdb.WithDir("/tmp/nutsdb"), // 数据库会自动创建这个目录文件
+ )
+ if err != nil {
+ log.Fatal(err)
+ }
+ defer db.Close()
+
+ ...
+}
+```
diff --git a/docs/tutorial/options.md b/docs/tutorial/options.md
new file mode 100644
index 0000000..8e6ec9a
--- /dev/null
+++ b/docs/tutorial/options.md
@@ -0,0 +1,98 @@
+# NutsDB 配置
+
+## NutsDB 配置选项
+
+* Dir string
+
+`Dir` 代表数据库存放数据的目录
+
+* EntryIdxMode EntryIdxMode
+
+`EntryIdxMode` 代表索引entry的模式.
+`EntryIdxMode` 包括选项: `HintKeyValAndRAMIdxMode` 、 `HintKeyAndRAMIdxMode`和 `HintBPTSparseIdxMode`。
+
+其中`HintKeyValAndRAMIdxMode` 代表纯内存索引模式（key和value都会被cache）。
+`HintKeyAndRAMIdxMode` 代表内存+磁盘的索引模式（只有key被cache）。
+`HintBPTSparseIdxMode`（v0.4.0之后的版本支持） 是专门节约内存的设计方案，单机10亿条数据，只要80几M内存。但是读性能不高，需要自己加缓存来加速。
+
+* RWMode RWMode
+
+`RWMode` 代表读写模式. `RWMode` 包括两种选项: `FileIO` and `MMap`.
+`FileIO` 用标准的 I/O读写。 `MMap` 代表使用mmap进行读写。
+
+* SegmentSize int64
+
+`SegmentSize` 代表数据库的数据单元，每个数据单元（文件）为`SegmentSize`，现在默认是8。**注意：从大于0.8.0版本开始，默认SegmentSize变成256MB**
+MB，这个可以自己配置。但是一旦被设置，下次启动数据库也要用这个配置，不然会报错。详情见 [限制和警告](https://github.com/nutsdb/nutsdb/blob/master/README-CN.md#%E8%AD%A6%E5%91%8A%E5%92%8C%E9%99%90%E5%88%B6)。
+
+* NodeNum int64
+
+`NodeNum` 代表节点的号码.默认 NodeNum是 1. `NodeNum` 取值范围 [1,1023] 。
+
+* SyncEnable bool
+
+`SyncEnable` 代表调用了 Sync() 方法.
+如果 `SyncEnable` 为 false， 写性能会很高，但是如果遇到断电或者系统奔溃，会有数据丢失的风险。
+如果 `SyncEnable` 为 true，写性能会相比false的情况慢很多，但是数据更有保障，每次事务提交成功都会落盘。
+
+* StartFileLoadingMode RWMode
+
+`StartFileLoadingMode` 代表启动数据库的载入文件的方式。参数选项同`RWMode`。
+
+* GCWhenClose bool
+
+`GCWhenClose` 表示调用 ```db.Close()``` 时主动 GC。Nutsdb 预设不会立即在 ```db.Close()``` 时触发 GC.
+
+* CommitBufferSize int64
+
+`CommitBufferSize` 表示为事务预分配的内存大小。Nutsdb 将预分配内存以减少内存分配的次数。
+
+* ErrorHandler ErrorHandler
+
+`ErrorHandler` 处理事务执行期间发生的错误。
+
+* LessFunc LessFunc
+
+`LessFunc` 表示对 key 进行排序的函数。Nutsdb 默认按字典序对 key 进行排序。
+
+* MergeInterval time.Duration
+
+`MergeInterval` 表示自动化 Merge 的间隔，0 表示不触发自动化 Merge，默认间隔为 2 小时。
+
+- MaxBatchCount int64
+
+`MaxBatchCount` 表示批量写入的最大条数。
+
+- MaxBatchSize int64
+
+`MaxBatchSize` 表示批量写入的最大字节数。
+
+- ExpiredDeleteType ExpiredDeleteType
+
+`ExpiredDeleteType ` 表示用于自动过期删除的数据结构。TimeWheel 意味着使用时间轮，你可以在需要高性能或者内存会充足的时候使用。TimeHeap 意味着使用时间轮，你可以在需要高精度删除或者内存将吃紧的时候使用。
+
+
+
+## 默认选项
+
+推荐使用默认选项的方式。兼顾了持久化+快速的启动数据库。当然具体还要看你场景的要求。
+
+> 以下配置是比较保守的方式。
+> 如果你对写性能要求比较高，可以设置SyncEnable等于false，RWMode改成MMap，写性能会得到极大提升，缺点是可能会丢数据（例如遇到断电或者系统奔溃）
+
+```
+var DefaultOptions = func() Options {
+ return Options{
+ EntryIdxMode: HintKeyValAndRAMIdxMode,
+ SegmentSize: defaultSegmentSize,
+ NodeNum: 1,
+ RWMode: FileIO,
+ SyncEnable: true,
+ CommitBufferSize: 4 * MB,
+ MergeInterval: 2 * time.Hour,
+ MaxBatchSize: (15 * defaultSegmentSize / 4) / 100,
+ MaxBatchCount: (15 * defaultSegmentSize / 4) / 100 / 100,
+ ExpiredDeleteType: TimeWheel,
+ }
+}()
+```
\ No newline at end of file
diff --git a/docs/tutorial/overview.md b/docs/tutorial/overview.md
new file mode 100644
index 0000000..1d378fb
--- /dev/null
+++ b/docs/tutorial/overview.md
@@ -0,0 +1 @@
+# NutsDB 手册概览
\ No newline at end of file
diff --git a/docs/tutorial/set.md b/docs/tutorial/set.md
new file mode 100644
index 0000000..d58b3c8
--- /dev/null
+++ b/docs/tutorial/set.md
@@ -0,0 +1,487 @@
+# 使用集合
+
+## SAdd
+
+添加一个指定的member元素到指定bucket的里的指定集合key中。
+
+```go
+if err := db.Update(
+ func(tx *nutsdb.Tx) error {
+ bucket := "bucketForSet"
+ key := []byte("mySet")
+ return tx.SAdd(bucket, key, []byte("a"), []byte("b"), []byte("c"))
+ }); err != nil {
+ log.Fatal(err)
+}
+```
+
+## SAreMembers
+
+返回多个成员member是否是指定bucket的里的指定集合key的成员。
+
+```go
+if err := db.View(
+ func(tx *nutsdb.Tx) error {
+ bucket := "bucketForSet"
+ key := []byte("mySet")
+ if ok, err := tx.SAreMembers(bucket, key, []byte("a"), []byte("b"), []byte("c")); err != nil {
+ return err
+ } else {
+ fmt.Println("SAreMembers:", ok)
+ }
+ return nil
+ }); err != nil {
+ log.Fatal(err)
+}
+```
+
+## SCard
+
+返回指定bucket的指定的集合key的基数 (集合元素的数量)。
+
+```go
+
+if err := db.View(
+ func(tx *nutsdb.Tx) error {
+ bucket := "bucketForSet"
+ key := []byte("mySet")
+ if num, err := tx.SCard(bucket, key); err != nil {
+ return err
+ } else {
+ fmt.Println("SCard:", num)
+ }
+ return nil
+ }); err != nil {
+ log.Fatal(err)
+}
+
+```
+## SDiffByOneBucket
+
+返回一个集合与给定集合的差集的元素。这两个集合都在一个bucket中。
+
+```go
+
+key1 := []byte("mySet1") // 集合1
+key2 := []byte("mySet2") // 集合2
+bucket := "bucketForSet"
+
+if err := db.Update(
+ func(tx *nutsdb.Tx) error {
+ return tx.SAdd(bucket, key1, []byte("a"), []byte("b"), []byte("c"))
+ }); err != nil {
+ log.Fatal(err)
+}
+
+if err := db.Update(
+ func(tx *nutsdb.Tx) error {
+ return tx.SAdd(bucket, key2, []byte("c"), []byte("d"))
+ }); err != nil {
+ log.Fatal(err)
+}
+
+if err := db.View(
+ func(tx *nutsdb.Tx) error {
+ if items, err := tx.SDiffByOneBucket(bucket, key1, key2); err != nil {
+ return err
+ } else {
+ fmt.Println("SDiffByOneBucket:", items)
+ for _, item := range items {
+ fmt.Println("item", string(item))
+ }
+ //item a
+ //item b
+ }
+ return nil
+ }); err != nil {
+ log.Fatal(err)
+}
+
+```
+
+## SDiffByTwoBuckets
+
+返回一个集合与给定集合的差集的元素。这两个集合分别在不同bucket中。
+
+```go
+bucket1 := "bucket1"
+key1 := []byte("mySet1")
+
+bucket2 := "bucket2"
+key2 := []byte("mySet2")
+
+if err := db.Update(
+ func(tx *nutsdb.Tx) error {
+ return tx.SAdd(bucket1, key1, []byte("a"), []byte("b"), []byte("c"))
+ }); err != nil {
+ log.Fatal(err)
+}
+
+if err := db.Update(
+ func(tx *nutsdb.Tx) error {
+ return tx.SAdd(bucket2, key2, []byte("c"), []byte("d"))
+ }); err != nil {
+ log.Fatal(err)
+}
+
+if err := db.View(
+ func(tx *nutsdb.Tx) error {
+ if items, err := tx.SDiffByTwoBuckets(bucket1, key1, bucket2, key2); err != nil {
+ return err
+ } else {
+ fmt.Println("SDiffByTwoBuckets:", items)
+ for _, item := range items {
+ fmt.Println("item", string(item))
+ }
+ }
+ return nil
+ }); err != nil {
+ log.Fatal(err)
+}
+
+```
+## SHasKey
+
+判断是否指定的集合在指定的bucket中。
+
+```go
+
+bucket := "bucketForSet"
+
+if err := db.View(
+ func(tx *nutsdb.Tx) error {
+ if ok, err := tx.SHasKey(bucket, []byte("mySet")); err != nil {
+ return err
+ } else {
+ fmt.Println("SHasKey", ok)
+ }
+ return nil
+ }); err != nil {
+ log.Fatal(err)
+}
+
+```
+## SIsMember
+
+返回成员member是否是指定bucket的存指定key集合的成员。
+
+```go
+bucket := "bucketForSet"
+
+if err := db.View(
+ func(tx *nutsdb.Tx) error {
+ if ok, err := tx.SIsMember(bucket, []byte("mySet"), []byte("a")); err != nil {
+ return err
+ } else {
+ fmt.Println("SIsMember", ok)
+ }
+ return nil
+ }); err != nil {
+ log.Fatal(err)
+}
+```
+## SMembers
+
+返回指定bucket的指定key集合所有的元素。
+
+```go
+bucket := "bucketForSet"
+
+if err := db.View(
+ func(tx *nutsdb.Tx) error {
+ if items, err := tx.SMembers(bucket, []byte("mySet")); err != nil {
+ return err
+ } else {
+ fmt.Println("SMembers", items)
+ for _, item := range items {
+ fmt.Println("item", string(item))
+ }
+ }
+ return nil
+ }); err != nil {
+ log.Fatal(err)
+}
+```
+## SMoveByOneBucket
+
+将member从source集合移动到destination集合中，其中source集合和destination集合均在一个bucket中。
+
+```go
+bucket3 := "bucket3"
+
+if err := db.Update(
+ func(tx *nutsdb.Tx) error {
+ return tx.SAdd(bucket3, []byte("mySet1"), []byte("a"), []byte("b"), []byte("c"))
+ }); err != nil {
+ log.Fatal(err)
+}
+if err := db.Update(
+ func(tx *nutsdb.Tx) error {
+ return tx.SAdd(bucket3, []byte("mySet2"), []byte("c"), []byte("d"), []byte("e"))
+ }); err != nil {
+ log.Fatal(err)
+}
+
+if err := db.Update(
+ func(tx *nutsdb.Tx) error {
+ if ok, err := tx.SMoveByOneBucket(bucket3, []byte("mySet1"), []byte("mySet2"), []byte("a")); err != nil {
+ return err
+ } else {
+ fmt.Println("SMoveByOneBucket", ok)
+ }
+ return nil
+ }); err != nil {
+ log.Fatal(err)
+}
+
+if err := db.View(
+ func(tx *nutsdb.Tx) error {
+ if items, err := tx.SMembers(bucket3, []byte("mySet1")); err != nil {
+ return err
+ } else {
+ fmt.Println("after SMoveByOneBucket bucket3 mySet1 SMembers", items)
+ for _, item := range items {
+ fmt.Println("item", string(item))
+ }
+ }
+ return nil
+ }); err != nil {
+ log.Fatal(err)
+}
+
+if err := db.View(
+ func(tx *nutsdb.Tx) error {
+ if items, err := tx.SMembers(bucket3, []byte("mySet2")); err != nil {
+ return err
+ } else {
+ fmt.Println("after SMoveByOneBucket bucket3 mySet2 SMembers", items)
+ for _, item := range items {
+ fmt.Println("item", string(item))
+ }
+ }
+ return nil
+ }); err != nil {
+ log.Fatal(err)
+}
+```
+## SMoveByTwoBuckets
+
+将member从source集合移动到destination集合中。其中source集合和destination集合在两个不同的bucket中。
+
+```go
+bucket4 := "bucket4"
+bucket5 := "bucket5"
+if err := db.Update(
+ func(tx *nutsdb.Tx) error {
+ return tx.SAdd(bucket4, []byte("mySet1"), []byte("a"), []byte("b"), []byte("c"))
+ }); err != nil {
+ log.Fatal(err)
+}
+if err := db.Update(
+ func(tx *nutsdb.Tx) error {
+ return tx.SAdd(bucket5, []byte("mySet2"), []byte("c"), []byte("d"), []byte("e"))
+ }); err != nil {
+ log.Fatal(err)
+}
+
+if err := db.Update(
+ func(tx *nutsdb.Tx) error {
+ if ok, err := tx.SMoveByTwoBuckets(bucket4, []byte("mySet1"), bucket5, []byte("mySet2"), []byte("a")); err != nil {
+ return err
+ } else {
+ fmt.Println("SMoveByTwoBuckets", ok)
+ }
+ return nil
+ }); err != nil {
+ log.Fatal(err)
+}
+
+if err := db.View(
+ func(tx *nutsdb.Tx) error {
+ if items, err := tx.SMembers(bucket4, []byte("mySet1")); err != nil {
+ return err
+ } else {
+ fmt.Println("after SMoveByTwoBuckets bucket4 mySet1 SMembers", items)
+ for _, item := range items {
+ fmt.Println("item", string(item))
+ }
+ }
+ return nil
+ }); err != nil {
+ log.Fatal(err)
+}
+
+if err := db.View(
+ func(tx *nutsdb.Tx) error {
+ if items, err := tx.SMembers(bucket5, []byte("mySet2")); err != nil {
+ return err
+ } else {
+ fmt.Println("after SMoveByTwoBuckets bucket5 mySet2 SMembers", items)
+ for _, item := range items {
+ fmt.Println("item", string(item))
+ }
+ }
+ return nil
+ }); err != nil {
+ log.Fatal(err)
+}
+```
+## SPop
+
+从指定bucket里的指定key的集合中移除并返回一个或多个随机元素。
+
+```go
+if err := db.Update(
+ func(tx *nutsdb.Tx) error {
+ key := []byte("mySet")
+ if item, err := tx.SPop(bucket, key); err != nil {
+ return err
+ } else {
+ fmt.Println("SPop item from mySet:", string(item))
+ }
+ return nil
+ }); err != nil {
+ log.Fatal(err)
+}
+```
+## SRem
+
+在指定bucket里面移除指定的key集合中移除指定的一个或者多个元素。
+
+```go
+bucket6:="bucket6"
+if err := db.Update(
+ func(tx *nutsdb.Tx) error {
+ return tx.SAdd(bucket6, []byte("mySet"), []byte("a"), []byte("b"), []byte("c"))
+ }); err != nil {
+ log.Fatal(err)
+}
+
+if err := db.Update(
+ func(tx *nutsdb.Tx) error {
+ if err := tx.SRem(bucket6, []byte("mySet"), []byte("a")); err != nil {
+ return err
+ } else {
+ fmt.Println("SRem ok")
+ }
+ return nil
+ }); err != nil {
+ log.Fatal(err)
+}
+
+if err := db.View(
+ func(tx *nutsdb.Tx) error {
+ if items, err := tx.SMembers(bucket6, []byte("mySet")); err != nil {
+ return err
+ } else {
+ fmt.Println("SMembers items:", items)
+ for _, item := range items {
+ fmt.Println("item:", string(item))
+ }
+ }
+ return nil
+ }); err != nil {
+ log.Fatal(err)
+}
+```
+## SUnionByOneBucket
+
+返回指定一个bucket里面的给定的两个集合的并集中的所有成员。
+
+```go
+bucket7 := "bucket1"
+key1 := []byte("mySet1")
+key2 := []byte("mySet2")
+
+if err := db.Update(
+ func(tx *nutsdb.Tx) error {
+ return tx.SAdd(bucket7, key1, []byte("a"), []byte("b"), []byte("c"))
+ }); err != nil {
+ log.Fatal(err)
+}
+
+if err := db.Update(
+ func(tx *nutsdb.Tx) error {
+ return tx.SAdd(bucket7, key2, []byte("c"), []byte("d"))
+ }); err != nil {
+ log.Fatal(err)
+}
+
+if err := db.View(
+ func(tx *nutsdb.Tx) error {
+ if items, err := tx.SUnionByOneBucket(bucket7, key1, key2); err != nil {
+ return err
+ } else {
+ fmt.Println("SUnionByOneBucket:", items)
+ for _, item := range items {
+ fmt.Println("item", string(item))
+ }
+ }
+ return nil
+ }); err != nil {
+ log.Fatal(err)
+}
+```
+
+## SUnionByTwoBuckets
+
+返回指定两个bucket里面的给定的两个集合的并集中的所有成员。
+
+```go
+bucket8 := "bucket1"
+key1 := []byte("mySet1")
+
+bucket9 := "bucket2"
+key2 := []byte("mySet2")
+
+if err := db.Update(
+ func(tx *nutsdb.Tx) error {
+ return tx.SAdd(bucket8, key1, []byte("a"), []byte("b"), []byte("c"))
+ }); err != nil {
+ log.Fatal(err)
+}
+
+if err := db.Update(
+ func(tx *nutsdb.Tx) error {
+ return tx.SAdd(bucket9, key2, []byte("c"), []byte("d"))
+ }); err != nil {
+ log.Fatal(err)
+}
+
+if err := db.View(
+ func(tx *nutsdb.Tx) error {
+ if items, err := tx.SUnionByTwoBuckets(bucket8, key1, bucket9, key2); err != nil {
+ return err
+ } else {
+ fmt.Println("SUnionByTwoBucket:", items)
+ for _, item := range items {
+ fmt.Println("item", string(item))
+ }
+ }
+ return nil
+ }); err != nil {
+ log.Fatal(err)
+}
+```
+
+## SKeys
+
+查找`Set`类型的所有匹配指定模式`pattern`的`key`，类似于Redis命令: [KEYS](https://redis.io/commands/keys/)
+
+注意：模式匹配使用 Go 标准库的`filepath.Match`，部分细节上和redis的行为有区别，比如对于 `[` 的处理。
+
+```go
+if err := db.View(
+ func(tx *nutsdb.Tx) error {
+ var keys []string
+ err := tx.SKeys(bucket, "*", func(key string) bool {
+ keys = append(keys, key)
+ // true: continue, false: break
+ return true
+ })
+ fmt.Printf("keys: %v\n", keys)
+ return err
+ }); err != nil {
+ log.Fatal(err)
+}
+```
diff --git a/docs/tutorial/sorted_set.md b/docs/tutorial/sorted_set.md
new file mode 100644
index 0000000..f04e934
--- /dev/null
+++ b/docs/tutorial/sorted_set.md
@@ -0,0 +1,576 @@
+# 使用有序集合
+
+> 注意：这边的bucket是有序集合名。
+
+## ZAdd
+
+将指定成员（包括key、score、value）添加到指定bucket的有序集合（sorted set）里面。
+
+
+```go
+if err := db.Update(
+ func(tx *nutsdb.Tx) error {
+ bucket := "myZSet1" // 注意：这边的bucket是有序集合名
+ key := []byte("key1")
+ return tx.ZAdd(bucket, key, 1, []byte("val1"))
+ }); err != nil {
+ log.Fatal(err)
+}
+```
+## ZCard
+
+返回指定bucket的的有序集元素个数。
+
+```go
+if err := db.View(
+ func(tx *nutsdb.Tx) error {
+ bucket := "myZSet1"
+ if num, err := tx.ZCard(bucket); err != nil {
+ return err
+ } else {
+ fmt.Println("ZCard num", num)
+ }
+ return nil
+ }); err != nil {
+ log.Fatal(err)
+}
+```
+
+## ZCount
+
+返回指定bucket的有序集，score值在min和max之间(默认包括score值等于start或end)的成员。
+
+Opts包含的参数：
+
+* Limit int // 限制返回的node数目
+* ExcludeStart bool // 排除start
+* ExcludeEnd bool // 排除end
+
+```go
+if err := db.View(
+ func(tx *nutsdb.Tx) error {
+ bucket := "myZSet1"
+ if num, err := tx.ZCount(bucket, 0, 1, nil); err != nil {
+ return err
+ } else {
+ fmt.Println("ZCount num", num)
+ }
+ return nil
+ }); err != nil {
+ log.Fatal(err)
+}
+```
+## ZGetByKey
+
+返回一个节点通过指定的bucket有序集合和指定的key来获取。
+
+```go
+if err := db.View(
+ func(tx *nutsdb.Tx) error {
+ bucket := "myZSet1"
+ key := []byte("key2")
+ if node, err := tx.ZGetByKey(bucket, key); err != nil {
+ return err
+ } else {
+ fmt.Println("ZGetByKey key2 val:", string(node.Value))
+ }
+ return nil
+ }); err != nil {
+ log.Fatal(err)
+}
+```
+## ZMembers
+
+返回所有成员通过在指定的bucket。
+
+```go
+if err := db.View(
+ func(tx *nutsdb.Tx) error {
+ bucket := "myZSet1"
+ if nodes, err := tx.ZMembers(bucket); err != nil {
+ return err
+ } else {
+ fmt.Println("ZMembers:", nodes)
+
+ for _, node := range nodes {
+ fmt.Println("member:", node.Key(), string(node.Value))
+ }
+ }
+ return nil
+ }); err != nil {
+ log.Fatal(err)
+}
+```
+## ZPeekMax
+
+返回指定bucket有序集合中的具有最高得分的成员。
+
+```go
+if err := db.View(
+ func(tx *nutsdb.Tx) error {
+ bucket := "myZSet1"
+ if node, err := tx.ZPeekMax(bucket); err != nil {
+ return err
+ } else {
+ fmt.Println("ZPeekMax:", string(node.Value))
+ }
+ return nil
+ }); err != nil {
+ log.Fatal(err)
+}
+```
+
+## ZPeekMin
+
+返回指定bucket有序集合中的具有最低得分的成员。
+
+```go
+if err := db.View(
+ func(tx *nutsdb.Tx) error {
+ bucket := "myZSet1"
+ if node, err := tx.ZPeekMin(bucket); err != nil {
+ return err
+ } else {
+ fmt.Println("ZPeekMin:", string(node.Value))
+ }
+ return nil
+ }); err != nil {
+ log.Fatal(err)
+}
+```
+
+## ZPopMax
+
+删除并返回指定bucket有序集合中的具有最高得分的成员。
+
+```go
+if err := db.Update(
+ func(tx *nutsdb.Tx) error {
+ bucket := "myZSet1"
+ if node, err := tx.ZPopMax(bucket); err != nil {
+ return err
+ } else {
+ fmt.Println("ZPopMax:", string(node.Value)) //val3
+ }
+ return nil
+ }); err != nil {
+ log.Fatal(err)
+}
+```
+## ZPopMin
+
+删除并返回指定bucket有序集合中的具有最低得分的成员。
+
+```go
+if err := db.Update(
+ func(tx *nutsdb.Tx) error {
+ bucket := "myZSet1"
+ if node, err := tx.ZPopMin(bucket); err != nil {
+ return err
+ } else {
+ fmt.Println("ZPopMin:", string(node.Value)) //val1
+ }
+ return nil
+ }); err != nil {
+ log.Fatal(err)
+}
+```
+
+## ZRangeByRank
+
+返回指定bucket有序集合的排名start到end的范围（包括start和end）的所有元素。
+
+```go
+// ZAdd add items
+if err := db.Update(
+ func(tx *nutsdb.Tx) error {
+ bucket := "myZSet2"
+ key1 := []byte("key1")
+ return tx.ZAdd(bucket, key1, 1, []byte("val1"))
+ }); err != nil {
+ log.Fatal(err)
+}
+
+if err := db.Update(
+ func(tx *nutsdb.Tx) error {
+ bucket := "myZSet2"
+ key2 := []byte("key2")
+ return tx.ZAdd(bucket, key2, 2, []byte("val2"))
+ }); err != nil {
+ log.Fatal(err)
+}
+
+if err := db.Update(
+ func(tx *nutsdb.Tx) error {
+ bucket := "myZSet2"
+ key3 := []byte("key3")
+ return tx.ZAdd(bucket, key3, 3, []byte("val3"))
+ }); err != nil {
+ log.Fatal(err)
+}
+
+// ZRangeByRank
+if err := db.View(
+ func(tx *nutsdb.Tx) error {
+ bucket := "myZSet2"
+ if nodes, err := tx.ZRangeByRank(bucket, 1, 2); err != nil {
+ return err
+ } else {
+ fmt.Println("ZRangeByRank nodes :", nodes)
+ for _, node := range nodes {
+ fmt.Println("item:", node.Key(), node.Score())
+ }
+
+ //item: key1 1
+ //item: key2 2
+ }
+ return nil
+ }); err != nil {
+ log.Fatal(err)
+}
+```
+
+## ZRangeByScore
+
+返回指定bucket有序集合的分数start到end的范围（包括start和end）的所有元素。其中有个`Opts`参数用法参考`ZCount`。
+
+```go
+// ZAdd
+if err := db.Update(
+ func(tx *nutsdb.Tx) error {
+ bucket := "myZSet3"
+ key1 := []byte("key1")
+ return tx.ZAdd(bucket, key1, 70, []byte("val1"))
+ }); err != nil {
+ log.Fatal(err)
+ }
+
+if err := db.Update(
+ func(tx *nutsdb.Tx) error {
+ bucket := "myZSet3"
+ key2 := []byte("key2")
+ return tx.ZAdd(bucket, key2, 90, []byte("val2"))
+ }); err != nil {
+ log.Fatal(err)
+}
+
+if err := db.Update(
+ func(tx *nutsdb.Tx) error {
+ bucket := "myZSet3"
+ key3 := []byte("key3")
+ return tx.ZAdd(bucket, key3, 86, []byte("val3"))
+ }); err != nil {
+ log.Fatal(err)
+}
+
+// ZRangeByScore
+if err := db.View(
+ func(tx *nutsdb.Tx) error {
+ bucket := "myZSet3"
+ if nodes, err := tx.ZRangeByScore(bucket, 80, 100,nil); err != nil {
+ return err
+ } else {
+ fmt.Println("ZRangeByScore nodes :", nodes)
+ for _, node := range nodes {
+ fmt.Println("item:", node.Key(), node.Score())
+ }
+ //item: key3 86
+ //item: key2 90
+ }
+ return nil
+ }); err != nil {
+ log.Fatal(err)
+}
+```
+## ZRank
+
+返回有序集bucket中成员指定成员key的排名。其中有序集成员按score值递增(从小到大)顺序排列。注意排名以1为底，也就是说，score值最小的成员排名为1。
+这点和Redis不同，Redis是从0开始的。
+
+```go
+
+// ZAdd
+if err := db.Update(
+ func(tx *nutsdb.Tx) error {
+ bucket := "myZSet4"
+ key1 := []byte("key1")
+ return tx.ZAdd(bucket, key1, 70, []byte("val1"))
+ }); err != nil {
+ log.Fatal(err)
+}
+
+if err := db.Update(
+ func(tx *nutsdb.Tx) error {
+ bucket := "myZSet4"
+ key2 := []byte("key2")
+ return tx.ZAdd(bucket, key2, 90, []byte("val2"))
+ }); err != nil {
+ log.Fatal(err)
+}
+
+if err := db.Update(
+ func(tx *nutsdb.Tx) error {
+ bucket := "myZSet4"
+ key3 := []byte("key3")
+ return tx.ZAdd(bucket, key3, 86, []byte("val3"))
+ }); err != nil {
+ log.Fatal(err)
+}
+
+// ZRank
+if err := db.View(
+ func(tx *nutsdb.Tx) error {
+ bucket := "myZSet4"
+ key1 := []byte("key1")
+ if rank, err := tx.ZRank(bucket, key1); err != nil {
+ return err
+ } else {
+ fmt.Println("key1 ZRank :", rank) // key1 ZRank : 1
+ }
+ return nil
+ }); err != nil {
+ log.Fatal(err)
+}
+```
+
+#### ZRevRank
+
+返回有序集bucket中成员指定成员key的反向排名。其中有序集成员还是按score值递增(从小到大)顺序排列。但是获取反向排名，注意排名还是以1为开始，也就是说，但是这个时候score值最大的成员排名为1。
+
+```go
+// ZAdd
+if err := db.Update(
+ func(tx *nutsdb.Tx) error {
+ bucket := "myZSet8"
+ key1 := []byte("key1")
+ return tx.ZAdd(bucket, key1, 10, []byte("val1"))
+ }); err != nil {
+ log.Fatal(err)
+}
+if err := db.Update(
+ func(tx *nutsdb.Tx) error {
+ bucket := "myZSet8"
+ key2 := []byte("key2")
+ return tx.ZAdd(bucket, key2, 20, []byte("val2"))
+ }); err != nil {
+ log.Fatal(err)
+}
+if err := db.Update(
+ func(tx *nutsdb.Tx) error {
+ bucket := "myZSet8"
+ key3 := []byte("key3")
+ return tx.ZAdd(bucket, key3, 30, []byte("val3"))
+ }); err != nil {
+ log.Fatal(err)
+}
+
+// ZRevRank
+if err := db.View(
+ func(tx *nutsdb.Tx) error {
+ bucket := "myZSet8"
+ if rank, err := tx.ZRevRank(bucket, []byte("key3")); err != nil {
+ return err
+ } else {
+ fmt.Println("ZRevRank key1 rank:", rank) //ZRevRank key3 rank: 1
+ }
+ return nil
+ }); err != nil {
+ log.Fatal(err)
+}
+```
+
+## ZRem
+
+删除指定成员key在一个指定的有序集合bucket中。
+
+```go
+if err := db.Update(
+ func(tx *nutsdb.Tx) error {
+ bucket := "myZSet5"
+ key1 := []byte("key1")
+ return tx.ZAdd(bucket, key1, 10, []byte("val1"))
+ }); err != nil {
+ log.Fatal(err)
+}
+
+if err := db.Update(
+ func(tx *nutsdb.Tx) error {
+ bucket := "myZSet5"
+ key2 := []byte("key2")
+ return tx.ZAdd(bucket, key2, 20, []byte("val2"))
+ }); err != nil {
+ log.Fatal(err)
+}
+
+if err := db.View(
+ func(tx *nutsdb.Tx) error {
+ bucket := "myZSet5"
+ if nodes,err := tx.ZMembers(bucket); err != nil {
+ return err
+ } else {
+ fmt.Println("before ZRem key1, ZMembers nodes",nodes)
+ for _,node:=range nodes {
+ fmt.Println("item:",node.Key(),node.Score())
+ }
+ }
+ // before ZRem key1, ZMembers nodes map[key1:0xc00008cfa0 key2:0xc00008d090]
+ // item: key1 10
+ // item: key2 20
+ return nil
+ }); err != nil {
+ log.Fatal(err)
+}
+
+if err := db.Update(
+ func(tx *nutsdb.Tx) error {
+ bucket := "myZSet5"
+ if err := tx.ZRem(bucket, "key1"); err != nil {
+ return err
+ }
+ return nil
+ }); err != nil {
+ log.Fatal(err)
+}
+
+if err := db.View(
+ func(tx *nutsdb.Tx) error {
+ bucket := "myZSet5"
+ if nodes,err := tx.ZMembers(bucket); err != nil {
+ return err
+ } else {
+ fmt.Println("after ZRem key1, ZMembers nodes",nodes)
+ for _,node:=range nodes {
+ fmt.Println("item:",node.Key(),node.Score())
+ }
+ // after ZRem key1, ZMembers nodes map[key2:0xc00008d090]
+ // item: key2 20
+ }
+ return nil
+ }); err != nil {
+ log.Fatal(err)
+}
+
+```
+
+## ZRemRangeByRank
+
+删除所有成员满足排名start到end（包括start和end）在一个指定的有序集合bucket中。其中排名以1开始，排名1表示第一个节点元素，排名-1表示最后的节点元素。
+
+```go
+if err := db.Update(
+ func(tx *nutsdb.Tx) error {
+ bucket := "myZSet6"
+ key1 := []byte("key1")
+ return tx.ZAdd(bucket, key1, 10, []byte("val1"))
+ }); err != nil {
+ log.Fatal(err)
+}
+
+if err := db.Update(
+ func(tx *nutsdb.Tx) error {
+ bucket := "myZSet6"
+ key2 := []byte("key2")
+ return tx.ZAdd(bucket, key2, 20, []byte("val2"))
+ }); err != nil {
+ log.Fatal(err)
+}
+
+if err := db.Update(
+ func(tx *nutsdb.Tx) error {
+ bucket := "myZSet6"
+ key3 := []byte("key3")
+ return tx.ZAdd(bucket, key3, 30, []byte("val2"))
+ }); err != nil {
+ log.Fatal(err)
+}
+
+if err := db.View(
+ func(tx *nutsdb.Tx) error {
+ bucket := "myZSet6"
+ if nodes,err := tx.ZMembers(bucket); err != nil {
+ return err
+ } else {
+ fmt.Println("before ZRemRangeByRank, ZMembers nodes",nodes)
+ for _,node:=range nodes {
+ fmt.Println("item:",node.Key(),node.Score())
+ }
+ // before ZRemRangeByRank, ZMembers nodes map[key3:0xc00008d450 key1:0xc00008d270 key2:0xc00008d360]
+ // item: key1 10
+ // item: key2 20
+ // item: key3 30
+ }
+ return nil
+ }); err != nil {
+ log.Fatal(err)
+}
+
+if err := db.Update(
+ func(tx *nutsdb.Tx) error {
+ bucket := "myZSet6"
+ if err := tx.ZRemRangeByRank(bucket, 1,2); err != nil {
+ return err
+ }
+ return nil
+ }); err != nil {
+ log.Fatal(err)
+}
+
+if err := db.View(
+ func(tx *nutsdb.Tx) error {
+ bucket := "myZSet6"
+ if nodes,err := tx.ZMembers(bucket); err != nil {
+ return err
+ } else {
+ fmt.Println("after ZRemRangeByRank, ZMembers nodes",nodes)
+ for _,node:=range nodes {
+ fmt.Println("item:",node.Key(),node.Score())
+ }
+ // after ZRemRangeByRank, ZMembers nodes map[key3:0xc00008d450]
+ // item: key3 30
+ // key1 ZScore 10
+ }
+ return nil
+ }); err != nil {
+ log.Fatal(err)
+}
+```
+## ZScore
+
+返回指定有序集bucket中，成员key的score值。
+
+```go
+if err := db.View(
+ func(tx *nutsdb.Tx) error {
+ bucket := "myZSet7"
+ if score,err := tx.ZScore(bucket, []byte("key1")); err != nil {
+ return err
+ } else {
+ fmt.Println("ZScore key1 score:",score)
+ }
+ return nil
+ }); err != nil {
+ log.Fatal(err)
+}
+```
+
+## ZKeys
+
+查找`Sorted Set`类型的所有匹配指定模式`pattern`的`key`，类似于Redis命令: [KEYS](https://redis.io/commands/keys/)
+
+注意：模式匹配使用 Go 标准库的`filepath.Match`，部分细节上和redis的行为有区别，比如对于 `[` 的处理。
+
+```go
+if err := db.View(
+ func(tx *nutsdb.Tx) error {
+ var keys []string
+ err := tx.ZKeys(bucket, "*", func(key string) bool {
+ keys = append(keys, key)
+ // true: continue, false: break
+ return true
+ })
+ fmt.Printf("keys: %v\n", keys)
+ return err
+ }); err != nil {
+ log.Fatal(err)
+}
+```
diff --git a/doc/zh-en/transaction.md b/docs/tutorial/transaction.md
similarity index 67%
rename from doc/zh-en/transaction.md
rename to docs/tutorial/transaction.md
index 612996e..f2f06d5 100644
--- a/doc/zh-en/transaction.md
+++ b/docs/tutorial/transaction.md
@@ -1,61 +1,61 @@
-### 使用事务
-
-NutsDB为了保证隔离性，防止并发读写事务时候数据的不一致性，同一时间只能执行一个读写事务，但是允许同一时间执行多个只读事务。
-从v0.3.0版本开始，NutsDB遵循标准的ACID原则。（参见[限制和警告](https://github.com/xujiajun/nutsdb/blob/master/README-CN.md#%E8%AD%A6%E5%91%8A%E5%92%8C%E9%99%90%E5%88%B6)）
-
-
-#### 读写事务
-
-```golang
-err := db.Update(
- func(tx *nutsdb.Tx) error {
- ...
- return nil
-})
-
-```
-
-#### 只读事务
-
-```golang
-err := db.View(
- func(tx *nutsdb.Tx) error {
- ...
- return nil
-})
-
-```
-
-#### 手动管理事务
-
-从上面的例子看到 `DB.View()` 和`DB.Update()` 这两个是数据库调用事务的主要方法。他们本质上是基于 `DB.Begin()`方法进行的包装。他们可以帮你自动管理事务的生命周期，从事务的开始、事务的执行、事务提交或者回滚一直到事务的安全的关闭为止，如果中间有错误会返回。所以**一般情况下推荐用这种方式去调用事务**。
-
-这好比开车有手动挡和自动挡一样， `DB.View()` 和`DB.Update()`等于提供了自动档的效果。
-
-如果你需要手动去开启、执行、关闭事务，你会用到`DB.Begin()`方法开启一个事务，`tx.Commit()` 方法用来提交事务、`tx.Rollback()`方法用来回滚事务
-
-例子：
-
-```golang
-//开始事务
-tx, err := db.Begin(true)
-if err != nil {
- return err
-}
-
-bucket := "bucket1"
-key := []byte("foo")
-val := []byte("bar")
-
-// 使用事务
-if err = tx.Put(bucket, key, val, Persistent); err != nil {
- // 回滚事务
- tx.Rollback()
-} else {
- // 提交事务
- if err = tx.Commit(); err != nil {
- tx.Rollback()
- return err
- }
-}
-```
\ No newline at end of file
+# 使用事务
+
+NutsDB为了保证隔离性，防止并发读写事务时候数据的不一致性，同一时间只能执行一个读写事务，但是允许同一时间执行多个只读事务。
+从v0.3.0版本开始，NutsDB遵循标准的ACID原则。（参见[限制和警告](https://github.com/nutsdb/nutsdb/blob/master/README-CN.md#%E8%AD%A6%E5%91%8A%E5%92%8C%E9%99%90%E5%88%B6)）
+
+
+## 读写事务
+
+```go
+err := db.Update(
+ func(tx *nutsdb.Tx) error {
+ ...
+ return nil
+})
+
+```
+
+## 只读事务
+
+```go
+err := db.View(
+ func(tx *nutsdb.Tx) error {
+ ...
+ return nil
+})
+
+```
+
+## 手动管理事务
+
+从上面的例子看到 `DB.View()` 和`DB.Update()` 这两个是数据库调用事务的主要方法。他们本质上是基于 `DB.Begin()`方法进行的包装。他们可以帮你自动管理事务的生命周期，从事务的开始、事务的执行、事务提交或者回滚一直到事务的安全的关闭为止，如果中间有错误会返回。所以**一般情况下推荐用这种方式去调用事务**。
+
+这好比开车有手动挡和自动挡一样， `DB.View()` 和`DB.Update()`等于提供了自动档的效果。
+
+如果你需要手动去开启、执行、关闭事务，你会用到`DB.Begin()`方法开启一个事务，`tx.Commit()` 方法用来提交事务、`tx.Rollback()`方法用来回滚事务
+
+例子：
+
+```go
+//开始事务
+tx, err := db.Begin(true)
+if err != nil {
+ return err
+}
+
+bucket := "bucket1"
+key := []byte("foo")
+val := []byte("bar")
+
+// 使用事务
+if err = tx.Put(bucket, key, val, nutsdb.Persistent); err != nil {
+ // 回滚事务
+ tx.Rollback()
+} else {
+ // 提交事务
+ if err = tx.Commit(); err != nil {
+ tx.Rollback()
+ return err
+ }
+}
+```
diff --git a/docusaurus.config.ts b/docusaurus.config.ts
new file mode 100644
index 0000000..7cba580
--- /dev/null
+++ b/docusaurus.config.ts
@@ -0,0 +1,195 @@
+import {themes as prismThemes} from 'prism-react-renderer';
+import type {Config} from '@docusaurus/types';
+import type * as Preset from '@docusaurus/preset-classic';
+
+const config: Config = {
+ title: 'NutsDB Documents',
+ tagline: 'NutsDB are cool',
+ favicon: 'img/icon.png',
+
+ // Set the production url of your site here
+ url: 'https://nutsdb.github.io/',
+ // Set the /{description}
+{siteConfig.tagline}
+