leveldb学习笔记之六——db/memtable.h

db数据在内存中的存储格式，写操作的数据都会先写到memtable中

类

class MemTable {
public:
    //构造函数，不允许隐式转换，参数为内部key比较器
    explicit MemTable(const InternalKeyComparator& comparator);

    //引用计数
    void Ref() { ++refs_; }

    //解引用
    void Unref() {
        --refs_;
        assert(refs_ >= 0);
        if (refs_ <= 0) {
            delete this;
        }
    }

    //评估当前的内存使用量
    size_t ApproximateMemoryUsage();

    //创建迭代器，用来遍历MemTable中的对象
    Iterator* NewIterator();

    //向MemTable中添加对象
    void Add(SequenceNumber seq, ValueType type,
           const Slice& key,
           const Slice& value);

    // 读取数据，提供查询键，输出对象值和状态
    bool Get(const LookupKey& key, std::string* value, Status* s);

 private:
    ~MemTable();  //析构函数私有化，使用者只能通过unref释放对象

    //比较器
    struct KeyComparator {
        const InternalKeyComparator comparator;
        explicit KeyComparator(const InternalKeyComparator& c) : comparator(c) { }
        int operator()(const char* a, const char* b) const;
    };
    friend class MemTableIterator;
    friend class MemTableBackwardIterator;
    
    //定义skiplist
    typedef SkipList<const char*, KeyComparator> Table;

    //成员变量包括键值比较器、引用计数、内存管理和跳表
    KeyComparator comparator_;
    int refs_;
    Arena arena_;
    Table table_;

    //禁止拷贝构造和赋值操作符
    MemTable(const MemTable&);
    void operator=(const MemTable&);
};

相关函数

主要分析以下几个函数：

• 写入数据的函数
  memtable写入数据的格式如下：
  
  代码如下：

void MemTable::Add(SequenceNumber s, ValueType type,
                   const Slice& key,
                   const Slice& value) {
    size_t key_size = key.size(); //key的长度
    size_t val_size = value.size(); //value的长度
    size_t internal_key_size = key_size + 8; //内部key的长度，因为内部key要加上序列号，序列号长度是8个字节
    const size_t encoded_len =    //编码后的总长度，key和value的长度分别用varint进行编码，所以总长度是此种计算方式
        VarintLength(internal_key_size) + internal_key_size +
        VarintLength(val_size) + val_size;
    char* buf = arena_.Allocate(encoded_len);   //分配空间
    char* p = EncodeVarint32(buf, internal_key_size); //首先写入内部key的长度（varint编码）
    memcpy(p, key.data(), key_size);  //再写key的数据
    p += key_size;
    EncodeFixed64(p, (s << 8) | type);   //然后写入类型数据
    p += 8;
    p = EncodeVarint32(p, val_size);    //继续写入value的长度（varint编码）
    memcpy(p, value.data(), val_size);  //写入value的数据
    assert(p + val_size == buf + encoded_len);
    table_.Insert(buf);   //将写入的数据插入到跳表中
}

• 读取数据

//读数据为写数据的逆向过程
bool MemTable::Get(const LookupKey& key, std::string* value, Status* s) {
    Slice memkey = key.memtable_key();  //获取memkey
    Table::Iterator iter(&table_);    //获取对应的跳表
    iter.Seek(memkey.data());     //查找到memkey对应的数据
    if (iter.Valid()) {
      const char* entry = iter.key();
      uint32_t key_length;
      const char* key_ptr = GetVarint32Ptr(entry, entry+5, &key_length);
      if (comparator_.comparator.user_comparator()->Compare(
              Slice(key_ptr, key_length - 8),
              key.user_key()) == 0) {

          // Correct user key
          const uint64_t tag = DecodeFixed64(key_ptr + key_length - 8);
          switch (static_cast<ValueType>(tag & 0xff)) {
            case kTypeValue: {//普通数据，直接查找后返回
                Slice v = GetLengthPrefixedSlice(key_ptr + key_length);
                value->assign(v.data(), v.size());
                return true;
            }
            case kTypeDeletion://已经删除的数据，返回NotFound
                *s = Status::NotFound(Slice());
                return true;
          }
      }
    }
    return false;
}

学习是一种慰藉，编程是一种情怀，技术提升永不可辜负！