共识算法-LevelDB

 LevleDB 是什么 

• leveldb 是 google 两位工程师使用 C++实现的单机版 k-v 存储系统
• key 和 value 都是任意的字节数组，支持内存和持久化存储 
• 数据都是按照 key 排序，用户可以重写排序函数
• 包含基本的数据操作接口，Put(key,value)，Get(key)，Delete(key)
• 多操作可以当成一次原子操作 

LevleDB 的局限性 

• leveldb 是非关系型数据库，不支持 SQL 查询也不支持索引
• 同一时间只支持单进程(支持多线程)访问 db
• 不支持客户端-服务器模型，用户需要自己封装 

LevelDB工作流程

LevelDB存储介质分为内存和硬盘两种

（一）内存：内存中有memtable 和immutable memtable

（二）硬盘：硬盘中有log文件，manifest文件，current文件和sstable文件

---

//DB的结构体
type DB struct {
	path string
	data map[string][]byte
}

//模拟开启
func New(path string) (*DB, error) {
	self := DB{
		path: path,
		data: make(map[string][]byte),
	}
	return &self, nil
}

//模拟关闭
func (self *DB) Close() error {
	return nil
}

Put

//Put
func (self *DB) Put(key []byte, value []byte) error {
	self.data[string(key)] = value
	return nil
}

Get

//Get
func (self *DB) Get(key []byte) ([]byte, error) {
	if v, ok := self.data[string(key)]; ok {
		return v, nil
	} else {
		//取不到
		return nil, fmt.Errorf("NotFound")
	}
}

Delete

//Delete
func (self *DB) Del(key []byte) (error) {
	if _, ok := self.data[string(key)]; ok {
		delete(self.data, string(key))
		return nil
	} else {
		return fmt.Errorf("NotFound")
	}
}

模拟遍历：

//定义
type Iterator interface {
	Next() bool
	Key() []byte
	Value() []byte
	Close() error
}

//定义一个键值对结构体
type Pair struct {
	Key   []byte
	Value []byte
}

//定义迭代器
type DefaultIterator struct {
	data   []Pair
	index  int
	length int
}

func NewDefaultIterator(data map[string][]byte) *DefaultIterator {
	//创建默认迭代器
	self := new(DefaultIterator)
	self.index = -1
	self.length = len(data)
	for k, v := range data {
		p := Pair{
			Key:   []byte(k),
			Value: v,
		}
		//遍历出的数据添加到data
		self.data = append(self.data, p)
	}
	return self
}

//是否存在下一个值
func (self *DefaultIterator) Next() bool {
	//若还有值，index加1
	if self.index < self.length-1 {
		self.index++
		return true
	}
	return false
}

func (self *DefaultIterator) Key() []byte {
	//判断是否越界
	if self.index == -1 || self.index >= self.length {
		panic(fmt.Errorf("越界"))
	}
	return self.data[self.index].Key
}

func (self *DefaultIterator) Value() []byte {
	//判断是否越界
	if self.index >= self.length {
		panic(fmt.Errorf("越界"))
	}
	return self.data[self.index].Value
}

func (self *DefaultIterator) Close() error {
	return nil
}