leveldb源码分析--Iterator遍历数据库

leveldb源码分析--Iterator遍历数据库

在DBImpl中有一个函数声明为Iterator* DBImpl::NewIterator(const ReadOptions& options) ，他返回一个可以遍历或者搜索数据库的迭代器句柄。

Iterator* DBImpl::NewIterator(const ReadOptions& options) { SequenceNumber latest_snapshot; uint32_t seed; Iterator* iter = NewInternalIterator(options, &latest_snapshot, &seed); return NewDBIterator( this, user_comparator(), iter, (options.snapshot != NULL ? reinterpret_cast<const SnapshotImpl*>(options.snapshot)->number_ : latest_snapshot),

可以看到这个函数就是获得一个内部迭代器句柄然后再用NewDBIterator包装返回一个DBIter，这个DBIter的目的就是作为内部迭代器的桥接封装的作用，方便用户调用。其接口函数大致有：

virtual bool Valid() const; virtual Slice key() cons; virtual Slice value() const; virtual Status status() const ; virtual void Next(); virtual void Prev(); virtual void Seek(const Slice& target); virtual void SeekToFirst(); virtual void SeekToLast();

这些封装只是对InternalIterator的一个简单封装，他们都以依赖于一个这个InternalIterator。我们来看看InternalIterator的获取

Iterator* DBImpl::NewInternalIterator(const ReadOptions& options, SequenceNumber* latest_snapshot, uint32_t* seed) { IterState* cleanup = new IterState; mutex_.Lock(); *latest_snapshot = versions_->LastSequence(); // Collect together all needed child iterators std::vector list; list.push_back(mem_->NewIterator()); mem_->Ref(); if (imm_ != NULL) { list.push_back(imm_->NewIterator()); imm_->Ref(); } versions_->current()->AddIterators(options, &list); Iterator* internal_iter = NewMergingIterator(&internal_comparator_, &list[0], list.size()); versions_->current()->Ref(); cleanup->mu = &mutex_; cleanup->mem = mem_; cleanup->imm = imm_; cleanup->version = versions_->current(); internal_iter->RegisterCleanup(CleanupIteratorState, cleanup, NULL); *seed = ++seed_; mutex_.Unlock(); return internal_iter; }

这里internal_iter的获取是从memTable、imm、还有version取得的所有与迭代器全部传入到一个MergingIterator中。在详细介绍这个MergingIterator前我们先来看看一个简化的例子，并且假设此时没有imm_table。这样我们现在有一个Memtable，SSTable中level0有两个文件，有一个level1的文件，里面的key大致如下(我们根据新旧程度排序，数据新旧依据请查阅Compaction章节）：

Memtable:  1,2,3,4,5,6

level0-2:     3,4,7,6

level0-1:     2,3,4,6

level1:        1,3,6,7,9…

这样，如果我们开始从第一个key开始以递增（Next）的方式遍历整个数据库，那么我们可以见到如下的过程。首先是每个初始化一个指向当前文件（这里暂时将Memtable也当做一个文件）第一个位置的指针，如下红色表示当前指向的指针：

Memtable:  1,3,4,5,6

level0-2:     3,4,7,6

level0-1:     2,3,4,6

level1:        1,3,6,7,9…

这样，我们根据数据最新关系我们很容易判断第一个key应该为Memtable中的1，我们记该当前key为1。然后再调用Next，调用Next的时候就需要将Memtable和level1中的当前指针key为1的向后一个key（level1中的移动在leveldb中是在FindSmallest中进行的），得到如下：

Memtable:  1,3,4,5,6

level0-2:     3,4,7,6

level0-1:     2,3,4,6

level1:        1,2,6,7,9…

那么这个时候我们也很容以判断这里的next的值应该是level0-1中的2。那么我做出这个判断的过程是怎么样的呢？应该是找出当前每个文件中指针指向的值中最小的那个key，如果有多个文件中当前指针key相同的时候，那么就应该取最新的那个文件中。再继续Next，

Memtable:  1,3,4,5,6

level0-2:     3,4,7,6

level0-1:     2,3,4,6

level1:        1,2,6,7,9…

那么此时应该是Memtable中的3。那么此时我们需要先前查找当前3的前一个呢？很明显我们应该回到上面第三个图的状态，应该level1，level0-1都进行回溯，然后选择最小的那个。但是如何能回到该状态呢？如果这样的话我们必须记录每次移动的过程，这种过程性的记录在程序设计中是十分难以做到的。而在leveldb中也采用了另外一种方式，就是在我们的迭代器器中记录一个当前遍历的值比如此时的level0-1中的3进行一个Prev，然后再查找最大值，最大值方式的时候如果大于3就继续往前回溯，再找到最大的最新的。形成的状态如下：

Memtable:  1,3,4,5,6                     //找到3，然后在prev到1

level0-2:     3,4,7,6                       //此处其实应该为invalid，即找到3，prev到invalid

level0-1:     2,3,4,6                      //找到3，prev到2

level1:        1,2,6,7,9…                 /找到6，prev到2

而查找的最大最新值也应该是level0-1中的2。

下面我们来看看代码Prev的实现：

virtual void Prev() { if (direction_ != kReverse) {// 如果之前遍历方向向后 for (int i = 0; i < n_; i++) { IteratorWrapper* child = &children_[i]; if (child != current_) { child->Seek(key());// 查找遍历当前值，然后再往前回溯 if (child->Valid()) { // Child is at first entry >= key(). Step back one to be < key() child->Prev(); } else { //没有>当前key值的key. child->SeekToLast(); } } } direction_ = kReverse; } current_->Prev(); FindLargest(); }

virtual void Next() {

 if (direction_ != kForward) { for (int i = 0; i < n_; i++) { IteratorWrapper* child = &children_[i]; if (child != current_) { child->Seek(key()); if (child->Valid() &&// 如果key为当前key相等，向后next comparator_->Compare(key(), child->key()) == 0) { child->Next(); } } } direction_ = kForward; } current_->Next(); FindSmallest(); }

所以再调用Next的过程就为：查找 >= 2的，如果找到并且==2就Next，然后找最小的最新的一个位置。

Memtable:  1,3,4,5,6                //找到3

level0-2:    3,4,7,6                  //找到3

level0-1:     2,3,4,6                  //这里是先找到2，然后再Next

level1:        1,2,6,7,9…              //同上

所以这里的操作就变成了查找

 

我们详细看看Next

void DBIter::Next() { assert(valid_); if (direction_ == kReverse) { // Switch directions? direction_ = kForward; // 如果上次已经到最后，回溯到第一个 if (!iter_->Valid()) { iter_->SeekToFirst(); } else { iter_->Next(); } if (!iter_->Valid()) { valid_ = false; saved_key_.clear(); return; } // saved_key_ already contains the key to skip past. } else { // 存储当前key，以备下次为Prev时查找这个key. SaveKey(ExtractUserKey(iter_->key()), &saved_key_); } FindNextUserEntry(true, &saved_key_); }

这里由于leveldb遍历数据库时涉及到多个数据文件及内存中的Memtable，所以每次调用prev和next时会有比较复杂的处理。

void DBIter::FindNextUserEntry(bool skipping, std::string* skip) { // Loop until we hit an acceptable entry to yield assert(iter_->Valid()); assert(direction_ == kForward); do { ParsedInternalKey ikey; if (ParseKey(&ikey) && ikey.sequence <= sequence_) { switch (ikey.type) { case kTypeDeletion: // 如果为删除，标记后面的已删除的key应该跳过 // 保存跳过的key  SaveKey(ikey.user_key, skip); skipping = true; break; case kTypeValue: if (skipping && user_comparator_->Compare(ikey.user_key, *skip) <= 0) { // 小于等于，跳过 } else {//找到值，返回 valid_ = true; saved_key_.clear(); return; } break; } } iter_->Next(); } while (iter_->Valid()); saved_key_.clear(); valid_ = false; }

这里我们不再对DBIter中的其他函数进行一一介绍，比如Prev和这里也是一个类似的（但是比较相反）处理过程。稍微提一下的是我们在void DBIter::FindPrevUserEntry() 中有如下一段代码

if (saved_value_.capacity() > raw_value.size() + 1048576) { std::string empty; swap(empty, saved_value_); }

这里当saved_value中的长度超过一定的值以后我们将其交换给一个零时变量，这样在超出其域以后析构时就可以对其内部的内存进行释放，而如果只是改变其大小内存则得不到释放。