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