LevelDB源码分析8-db key

为了更好的阅读Memtable，先看一看Memtable的key.

ValueType

levledb更新时不会操控db中的数据，每次操作都是直接插入一份kv数据，具体的数据合并和清除工作由后台的compact完成。所以，每次 put，db 中就会新加入一份 KV 数据，即使该 key 已经存在；而 delete 等同于 put 空的 value。为了区分真实 kv 数据和删除操作的 mock 数据，使用 ValueType 来标识：

enum ValueType {
  kTypeDeletion = 0x0, //删除的key
  kTypeValue = 0x1 //插入的key
};

SequenceNumber

SequenceNumber的定义为：typedef uint64_t SequenceNumber;.可见sequenceNumber是一个64位的数。每次更新时，由SequenceNumber来标识，整个 db 有一个全局值保存着当前使用到的 SequnceNumber。SequnceNumber 在 leveldb 有重要的地位，key 的排序，compact 以及 snapshot 都依赖于它。存储结构如下:

0	56
SequenceNumber	ValueType

SequnceNumber只占56bits,ValueType占用8bits.

因此定义了其最大值：

//SequenceNumber的最大值，56位
static const SequenceNumber kMaxSequenceNumber =
    ((0x1ull << 56) - 1);

ParsedInternalKey

ParsedInternalKey为db内部操作的key.db内部需要把user key(用户传入的key,为Slice格式)加入元信息一并处理。

//db内部操作的key,对用户传入的key(Slice)加入一个信息
struct ParsedInternalKey {
  Slice user_key;
  SequenceNumber sequence;
  ValueType type;

  ParsedInternalKey() { }  // Intentionally left uninitialized (for speed)
  ParsedInternalKey(const Slice& u, const SequenceNumber& seq, ValueType t)
      : user_key(u), sequence(seq), type(t) { }
  std::string DebugString() const;
};

转换函数：

//把一个slice形式的internal_key转为一个ParsedInternalKey的struct
inline bool ParseInternalKey(const Slice& internal_key,
                             ParsedInternalKey* result) {
  const size_t n = internal_key.size();
  if (n < 8) return false;
  uint64_t num = DecodeFixed64(internal_key.data() + n - 8);//seq+type
  unsigned char c = num & 0xff;
  result->sequence = num >> 8;
  result->type = static_cast<ValueType>(c);
  result->user_key = Slice(internal_key.data(), n - 8);//user_key
  return (c <= static_cast<unsigned char>(kTypeValue));
}

　InternalKey

InternalKey为db内部使用，包装易用的结构，包含userkey于SequnceNumber/ValueType

InternalKey是内部成员为一个rep_(string).这个string组成为ParseInternalKey的元素：

//增加一个key的操作
void AppendInternalKey(std::string* result, const ParsedInternalKey& key) {
  result->append(key.user_key.data(), key.user_key.size());//user key
  PutFixed64(result, PackSequenceAndType(key.sequence, key.type));// SequenceNumber 和 ValueType
}

整体的结果如下

//InternalKey
class InternalKey {
 private:
  std::string rep_;//a string represent all the information
 public:
  InternalKey() { }   // Leave rep_ as empty to indicate it is invalid
  //InternalKey string consist of (user_key)
  InternalKey(const Slice& user_key, SequenceNumber s, ValueType t) {
    AppendInternalKey(&rep_, ParsedInternalKey(user_key, s, t));
  }

  void DecodeFrom(const Slice& s) { rep_.assign(s.data(), s.size()); }
  Slice Encode() const {
    assert(!rep_.empty());
    return rep_;
  }

  Slice user_key() const { return ExtractUserKey(rep_); }

  void SetFrom(const ParsedInternalKey& p) {
    rep_.clear();
    AppendInternalKey(&rep_, p);
  }

  void Clear() { rep_.clear(); }

  std::string DebugString() const;
};

LookupKey

db内部在memetable中查找数据使用

//LookupKey：db内部在memtable中查找数据
class LookupKey {
 public:
  // Initialize *this for looking up user_key at a snapshot with
  // the specified sequence number.
  LookupKey(const Slice& user_key, SequenceNumber sequence);

  ~LookupKey();

  // Return a key suitable for lookup in a MemTable.
  Slice memtable_key() const { return Slice(start_, end_ - start_); }

  // Return an internal key (suitable for passing to an internal iterator)
  Slice internal_key() const { return Slice(kstart_, end_ - kstart_); }

  // Return the user key
  Slice user_key() const { return Slice(kstart_, end_ - kstart_ - 8); }

 private:
  // We construct a char array of the form:
  //    klength  varint32               <-- start_
  //    userkey  char[klength]          <-- kstart_
  //    tag      uint64
  //                                    <-- end_
  // The array is a suitable MemTable key.
  // The suffix starting with "userkey" can be used as an InternalKey.
  const char* start_;
  const char* kstart_;
  const char* end_;
  char space_[200];      // Avoid allocation for short keys

  // No copying allowed
  LookupKey(const LookupKey&);
  void operator=(const LookupKey&);
};

inline LookupKey::~LookupKey() {
  if (start_ != space_) delete[] start_;
}

SkipList中的key

skiplist中的单个节点不仅存储了Key，也存储了value.格式如下图。内部的比较函数使用的是InternalKey。