leveldb::anonymous_namespace{db_iter.cc}::DBIter Class Reference

Inheritance diagram for leveldb::anonymous_namespace{db_iter.cc}::DBIter:

Collaboration diagram for leveldb::anonymous_namespace{db_iter.cc}::DBIter:

Public Types
enum	Direction { kForward, kReverse }
Public Types inherited from leveldb::Iterator
typedef void(*	CleanupFunction) (void *arg1, void *arg2)

Public Member Functions
	DBIter (DBImpl *db, const Comparator *cmp, Iterator *iter, SequenceNumber s, uint32_t seed)
virtual	~DBIter ()
virtual bool	Valid () const
virtual Slice	key () const
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 ()
Public Member Functions inherited from leveldb::Iterator
	Iterator ()
virtual	~Iterator ()
void	RegisterCleanup (CleanupFunction function, void *arg1, void *arg2)

Private Member Functions
void	FindNextUserEntry (bool skipping, std::string *skip)
void	FindPrevUserEntry ()
bool	ParseKey (ParsedInternalKey *key)
void	SaveKey (const Slice &k, std::string *dst)
void	ClearSavedValue ()
ssize_t	RandomPeriod ()
	DBIter (const DBIter &)
void	operator= (const DBIter &)

Private Attributes
DBImpl *	db_
const Comparator *const	user_comparator_
Iterator *const	iter_
SequenceNumber const	sequence_
Status	status_
std::string	saved_key_
std::string	saved_value_
Direction	direction_
bool	valid_
Random	rnd_
ssize_t	bytes_counter_

Detailed Description

Definition at line 39 of file db_iter.cc.

Member Enumeration Documentation

Direction

enum leveldb::anonymous_namespace{db_iter.cc}::DBIter::Direction

Enumerator
kForward
kReverse

Definition at line 46 of file db_iter.cc.

                 {
    kForward,
    kReverse
  };

Constructor & Destructor Documentation

DBIter() [1/2]

leveldb::anonymous_namespace{db_iter.cc}::DBIter::DBIter ( DBImpl *  db, const Comparator *  cmp, Iterator *  iter, SequenceNumber  s, uint32_t  seed  )

inline

Definition at line 51 of file db_iter.cc.

      : db_(db),
        user_comparator_(cmp),
        iter_(iter),
        sequence_(s),
        direction_(kForward),
        valid_(false),
        rnd_(seed),
        bytes_counter_(RandomPeriod()) {
  }

~DBIter()

virtual leveldb::anonymous_namespace{db_iter.cc}::DBIter::~DBIter ( )

inlinevirtual

Definition at line 62 of file db_iter.cc.

                    {
    delete iter_;
  }

DBIter() [2/2]

leveldb::anonymous_namespace{db_iter.cc}::DBIter::DBIter ( const DBIter &  )

private

Member Function Documentation

ClearSavedValue()

void leveldb::anonymous_namespace{db_iter.cc}::DBIter::ClearSavedValue ( )

inlineprivate

Definition at line 97 of file db_iter.cc.

                                {
    if (saved_value_.capacity() > 1048576) {
      std::string empty;
      swap(empty, saved_value_);
    } else {
      saved_value_.clear();
    }
  }

FindNextUserEntry()

void leveldb::anonymous_namespace{db_iter.cc}::DBIter::FindNextUserEntry ( bool  skipping, std::string *  skip  )

private

Definition at line 173 of file db_iter.cc.

                                                             {
  // 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:
          // Arrange to skip all upcoming entries for this key since
          // they are hidden by this deletion.
          SaveKey(ikey.user_key, skip);
          skipping = true;
          break;
        case kTypeValue:
          if (skipping &&
              user_comparator_->Compare(ikey.user_key, *skip) <= 0) {
            // Entry hidden
          } else {
            valid_ = true;
            saved_key_.clear();
            return;
          }
          break;
      }
    }
    iter_->Next();
  } while (iter_->Valid());
  saved_key_.clear();
  valid_ = false;
}

FindPrevUserEntry()

void leveldb::anonymous_namespace{db_iter.cc}::DBIter::FindPrevUserEntry ( )

private

Definition at line 232 of file db_iter.cc.

                               {
  assert(direction_ == kReverse);

  ValueType value_type = kTypeDeletion;
  if (iter_->Valid()) {
    do {
      ParsedInternalKey ikey;
      if (ParseKey(&ikey) && ikey.sequence <= sequence_) {
        if ((value_type != kTypeDeletion) &&
            user_comparator_->Compare(ikey.user_key, saved_key_) < 0) {
          // We encountered a non-deleted value in entries for previous keys,
          break;
        }
        value_type = ikey.type;
        if (value_type == kTypeDeletion) {
          saved_key_.clear();
          ClearSavedValue();
        } else {
          Slice raw_value = iter_->value();
          if (saved_value_.capacity() > raw_value.size() + 1048576) {
            std::string empty;
            swap(empty, saved_value_);
          }
          SaveKey(ExtractUserKey(iter_->key()), &saved_key_);
          saved_value_.assign(raw_value.data(), raw_value.size());
        }
      }
      iter_->Prev();
    } while (iter_->Valid());
  }

  if (value_type == kTypeDeletion) {
    // End
    valid_ = false;
    saved_key_.clear();
    ClearSavedValue();
    direction_ = kForward;
  } else {
    valid_ = true;
  }
}

Here is the call graph for this function:

key()

virtual Slice leveldb::anonymous_namespace{db_iter.cc}::DBIter::key ( ) const

inlinevirtual

Implements leveldb::Iterator.

Definition at line 66 of file db_iter.cc.

                            {
    assert(valid_);
    return (direction_ == kForward) ? ExtractUserKey(iter_->key()) : saved_key_;
  }

Here is the call graph for this function:

Next()

void leveldb::anonymous_namespace{db_iter.cc}::DBIter::Next ( )

virtual

Implements leveldb::Iterator.

Definition at line 146 of file db_iter.cc.

                  {
  assert(valid_);

  if (direction_ == kReverse) {  // Switch directions?
    direction_ = kForward;
    // iter_ is pointing just before the entries for this->key(),
    // so advance into the range of entries for this->key() and then
    // use the normal skipping code below.
    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 {
    // Store in saved_key_ the current key so we skip it below.
    SaveKey(ExtractUserKey(iter_->key()), &saved_key_);
  }

  FindNextUserEntry(true, &saved_key_);
}

Here is the call graph for this function:

operator=()

void leveldb::anonymous_namespace{db_iter.cc}::DBIter::operator= ( const DBIter &  )

private

ParseKey()

bool leveldb::anonymous_namespace{db_iter.cc}::DBIter::ParseKey ( ParsedInternalKey *  key )

inlineprivate

Definition at line 130 of file db_iter.cc.

                                                    {
  Slice k = iter_->key();
  ssize_t n = k.size() + iter_->value().size();
  bytes_counter_ -= n;
  while (bytes_counter_ < 0) {
    bytes_counter_ += RandomPeriod();
    db_->RecordReadSample(k);
  }
  if (!ParseInternalKey(k, ikey)) {
    status_ = Status::Corruption("corrupted internal key in DBIter");
    return false;
  } else {
    return true;
  }
}

Here is the call graph for this function:

Prev()

void leveldb::anonymous_namespace{db_iter.cc}::DBIter::Prev ( )

virtual

Implements leveldb::Iterator.

Definition at line 205 of file db_iter.cc.

                  {
  assert(valid_);

  if (direction_ == kForward) {  // Switch directions?
    // iter_ is pointing at the current entry.  Scan backwards until
    // the key changes so we can use the normal reverse scanning code.
    assert(iter_->Valid());  // Otherwise valid_ would have been false
    SaveKey(ExtractUserKey(iter_->key()), &saved_key_);
    while (true) {
      iter_->Prev();
      if (!iter_->Valid()) {
        valid_ = false;
        saved_key_.clear();
        ClearSavedValue();
        return;
      }
      if (user_comparator_->Compare(ExtractUserKey(iter_->key()),
                                    saved_key_) < 0) {
        break;
      }
    }
    direction_ = kReverse;
  }

  FindPrevUserEntry();
}

Here is the call graph for this function:

RandomPeriod()

ssize_t leveldb::anonymous_namespace{db_iter.cc}::DBIter::RandomPeriod ( )

inlineprivate

Definition at line 107 of file db_iter.cc.

                         {
    return rnd_.Uniform(2*config::kReadBytesPeriod);
  }

SaveKey()

void leveldb::anonymous_namespace{db_iter.cc}::DBIter::SaveKey ( const Slice &  k, std::string *  dst  )

inlineprivate

Definition at line 93 of file db_iter.cc.

                                                      {
    dst->assign(k.data(), k.size());
  }

Here is the call graph for this function:

Seek()

void leveldb::anonymous_namespace{db_iter.cc}::DBIter::Seek ( const Slice &  target )

virtual

Implements leveldb::Iterator.

Definition at line 274 of file db_iter.cc.

                                     {
  direction_ = kForward;
  ClearSavedValue();
  saved_key_.clear();
  AppendInternalKey(
      &saved_key_, ParsedInternalKey(target, sequence_, kValueTypeForSeek));
  iter_->Seek(saved_key_);
  if (iter_->Valid()) {
    FindNextUserEntry(false, &saved_key_ /* temporary storage */);
  } else {
    valid_ = false;
  }
}

Here is the call graph for this function:

SeekToFirst()

void leveldb::anonymous_namespace{db_iter.cc}::DBIter::SeekToFirst ( )

virtual

Implements leveldb::Iterator.

Definition at line 288 of file db_iter.cc.

                         {
  direction_ = kForward;
  ClearSavedValue();
  iter_->SeekToFirst();
  if (iter_->Valid()) {
    FindNextUserEntry(false, &saved_key_ /* temporary storage */);
  } else {
    valid_ = false;
  }
}

SeekToLast()

void leveldb::anonymous_namespace{db_iter.cc}::DBIter::SeekToLast ( )

virtual

Implements leveldb::Iterator.

Definition at line 299 of file db_iter.cc.

                        {
  direction_ = kReverse;
  ClearSavedValue();
  iter_->SeekToLast();
  FindPrevUserEntry();
}

status()

virtual Status leveldb::anonymous_namespace{db_iter.cc}::DBIter::status ( ) const

inlinevirtual

Implements leveldb::Iterator.

Definition at line 74 of file db_iter.cc.

                                {
    if (status_.ok()) {
      return iter_->status();
    } else {
      return status_;
    }
  }

Valid()

virtual bool leveldb::anonymous_namespace{db_iter.cc}::DBIter::Valid ( ) const

inlinevirtual

Implements leveldb::Iterator.

Definition at line 65 of file db_iter.cc.

{ return valid_; }

value()

virtual Slice leveldb::anonymous_namespace{db_iter.cc}::DBIter::value ( ) const

inlinevirtual

Implements leveldb::Iterator.

Definition at line 70 of file db_iter.cc.

                              {
    assert(valid_);
    return (direction_ == kForward) ? iter_->value() : saved_value_;
  }

Member Data Documentation

bytes_counter_

ssize_t leveldb::anonymous_namespace{db_iter.cc}::DBIter::bytes_counter_

private

Definition at line 123 of file db_iter.cc.

db_

DBImpl* leveldb::anonymous_namespace{db_iter.cc}::DBIter::db_

private

Definition at line 111 of file db_iter.cc.

direction_

Direction leveldb::anonymous_namespace{db_iter.cc}::DBIter::direction_

private

Definition at line 119 of file db_iter.cc.

iter_

Iterator* const leveldb::anonymous_namespace{db_iter.cc}::DBIter::iter_

private

Definition at line 113 of file db_iter.cc.

rnd_

Random leveldb::anonymous_namespace{db_iter.cc}::DBIter::rnd_

private

Definition at line 122 of file db_iter.cc.

saved_key_

std::string leveldb::anonymous_namespace{db_iter.cc}::DBIter::saved_key_

private

Definition at line 117 of file db_iter.cc.

saved_value_

std::string leveldb::anonymous_namespace{db_iter.cc}::DBIter::saved_value_

private

Definition at line 118 of file db_iter.cc.

sequence_

SequenceNumber const leveldb::anonymous_namespace{db_iter.cc}::DBIter::sequence_

private

Definition at line 114 of file db_iter.cc.

status_

Status leveldb::anonymous_namespace{db_iter.cc}::DBIter::status_

private

Definition at line 116 of file db_iter.cc.

user_comparator_

const Comparator* const leveldb::anonymous_namespace{db_iter.cc}::DBIter::user_comparator_

private

Definition at line 112 of file db_iter.cc.

valid_

bool leveldb::anonymous_namespace{db_iter.cc}::DBIter::valid_

private

Definition at line 120 of file db_iter.cc.

---

The documentation for this class was generated from the following file:

• db/db_iter.cc