leveldb::MemTable Class Reference

#include <memtable.h>

Collaboration diagram for leveldb::MemTable:

Classes
struct	KeyComparator

Public Member Functions
	MemTable (const InternalKeyComparator &comparator)
void	Ref ()
void	Unref ()
size_t	ApproximateMemoryUsage ()
Iterator *	NewIterator ()
void	Add (SequenceNumber seq, ValueType type, const Slice &key, const Slice &value)
bool	Get (const LookupKey &key, std::string *value, Status *s)

Private Types
typedef SkipList< const char *, KeyComparator >	Table

Private Member Functions
	~MemTable ()
	MemTable (const MemTable &)
void	operator= (const MemTable &)

Private Attributes
KeyComparator	comparator_
int	refs_
Arena	arena_
Table	table_

Friends
class	MemTableIterator
class	MemTableBackwardIterator

Detailed Description

Definition at line 20 of file memtable.h.

Member Typedef Documentation

Table

typedef SkipList<const char*, KeyComparator> leveldb::MemTable::Table

private

Definition at line 74 of file memtable.h.

Constructor & Destructor Documentation

MemTable() [1/2]

leveldb::MemTable::MemTable ( const InternalKeyComparator &  comparator )

explicit

Definition at line 21 of file memtable.cc.

    : comparator_(cmp),
      refs_(0),
      table_(comparator_, &arena_) {
}

~MemTable()

leveldb::MemTable::~MemTable ( )

private

Definition at line 27 of file memtable.cc.

                    {
  assert(refs_ == 0);
}

Here is the caller graph for this function:

MemTable() [2/2]

leveldb::MemTable::MemTable ( const MemTable &  )

private

Member Function Documentation

Add()

void leveldb::MemTable::Add	(	SequenceNumber	seq,
		ValueType	type,
		const Slice &	key,
		const Slice &	value
	)

Definition at line 82 of file memtable.cc.

                                       {
  // Format of an entry is concatenation of:
  //  key_size     : varint32 of internal_key.size()
  //  key bytes    : char[internal_key.size()]
  //  value_size   : varint32 of value.size()
  //  value bytes  : char[value.size()]
  size_t key_size = key.size();
  size_t val_size = value.size();
  size_t internal_key_size = key_size + 8;
  const size_t encoded_len =
      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);
  memcpy(p, key.data(), key_size);
  p += key_size;
  EncodeFixed64(p, (s << 8) | type);
  p += 8;
  p = EncodeVarint32(p, val_size);
  memcpy(p, value.data(), val_size);
  assert((p + val_size) - buf == encoded_len);
  table_.Insert(buf);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ApproximateMemoryUsage()

size_t leveldb::MemTable::ApproximateMemoryUsage

(

)

Definition at line 31 of file memtable.cc.

{ return arena_.MemoryUsage(); }

Here is the call graph for this function:

Here is the caller graph for this function:

Get()

bool leveldb::MemTable::Get	(	const LookupKey &	key,
		std::string *	value,
		Status *	s
	)

Definition at line 108 of file memtable.cc.

                                                                    {
  Slice memkey = key.memtable_key();
  Table::Iterator iter(&table_);
  iter.Seek(memkey.data());
  if (iter.Valid()) {
    // entry format is:
    //    klength  varint32
    //    userkey  char[klength]
    //    tag      uint64
    //    vlength  varint32
    //    value    char[vlength]
    // Check that it belongs to same user key.  We do not check the
    // sequence number since the Seek() call above should have skipped
    // all entries with overly large sequence numbers.
    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:
          *s = Status::NotFound(Slice());
          return true;
      }
    }
  }
  return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

NewIterator()

Iterator * leveldb::MemTable::NewIterator

(

)

Definition at line 78 of file memtable.cc.

                                {
  return new MemTableIterator(&table_);
}

Here is the caller graph for this function:

operator=()

void leveldb::MemTable::operator= ( const MemTable &  )

private

Ref()

void leveldb::MemTable::Ref ( )

inline

Definition at line 27 of file memtable.h.

{ ++refs_; }

Here is the caller graph for this function:

Unref()

void leveldb::MemTable::Unref ( )

inline

Definition at line 30 of file memtable.h.

               {
    --refs_;
    assert(refs_ >= 0);
    if (refs_ <= 0) {
      delete this;
    }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Function Documentation

MemTableBackwardIterator

friend class MemTableBackwardIterator

friend

Definition at line 72 of file memtable.h.

MemTableIterator

friend class MemTableIterator

friend

Definition at line 71 of file memtable.h.

Member Data Documentation

arena_

Arena leveldb::MemTable::arena_

private

Definition at line 78 of file memtable.h.

comparator_

KeyComparator leveldb::MemTable::comparator_

private

Definition at line 76 of file memtable.h.

refs_

int leveldb::MemTable::refs_

private

Definition at line 77 of file memtable.h.

table_

Table leveldb::MemTable::table_

private

Definition at line 79 of file memtable.h.

---

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

• db/memtable.h
• db/memtable.cc