leveldb::TableCache Class Reference

#include <table_cache.h>

Collaboration diagram for leveldb::TableCache:

Public Member Functions
	TableCache (const std::string &dbname, const Options *options, int entries)
	~TableCache ()
Iterator *	NewIterator (const ReadOptions &options, uint64_t file_number, uint64_t file_size, Table **tableptr=NULL)
Status	Get (const ReadOptions &options, uint64_t file_number, uint64_t file_size, const Slice &k, void *arg, void(*handle_result)(void *, const Slice &, const Slice &))
void	Evict (uint64_t file_number)

Private Member Functions
Status	FindTable (uint64_t file_number, uint64_t file_size, Cache::Handle **)

Private Attributes
Env *const	env_
const std::string	dbname_
const Options *	options_
Cache *	cache_

Detailed Description

Definition at line 21 of file table_cache.h.

Constructor & Destructor Documentation

TableCache()

leveldb::TableCache::TableCache	(	const std::string &	dbname,
		const Options *	options,
		int	entries
	)

Definition at line 32 of file table_cache.cc.

    : env_(options->env),
      dbname_(dbname),
      options_(options),
      cache_(NewLRUCache(entries)) {
}

~TableCache()

leveldb::TableCache::~TableCache

(

)

Definition at line 41 of file table_cache.cc.

                        {
  delete cache_;
}

Member Function Documentation

Evict()

void leveldb::TableCache::Evict

(

uint64_t

file_number

)

Definition at line 121 of file table_cache.cc.

                                           {
  char buf[sizeof(file_number)];
  EncodeFixed64(buf, file_number);
  cache_->Erase(Slice(buf, sizeof(buf)));
}

Here is the call graph for this function:

Here is the caller graph for this function:

FindTable()

Status leveldb::TableCache::FindTable ( uint64_t  file_number, uint64_t  file_size, Cache::Handle **  handle  )

private

Definition at line 45 of file table_cache.cc.

                                                   {
  Status s;
  char buf[sizeof(file_number)];
  EncodeFixed64(buf, file_number);
  Slice key(buf, sizeof(buf));
  *handle = cache_->Lookup(key);
  if (*handle == NULL) {
    std::string fname = TableFileName(dbname_, file_number);
    RandomAccessFile* file = NULL;
    Table* table = NULL;
    s = env_->NewRandomAccessFile(fname, &file);
    if (!s.ok()) {
      std::string old_fname = SSTTableFileName(dbname_, file_number);
      if (env_->NewRandomAccessFile(old_fname, &file).ok()) {
        s = Status::OK();
      }
    }
    if (s.ok()) {
      s = Table::Open(*options_, file, file_size, &table);
    }

    if (!s.ok()) {
      assert(table == NULL);
      delete file;
      // We do not cache error results so that if the error is transient,
      // or somebody repairs the file, we recover automatically.
    } else {
      TableAndFile* tf = new TableAndFile;
      tf->file = file;
      tf->table = table;
      *handle = cache_->Insert(key, tf, 1, &DeleteEntry);
    }
  }
  return s;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Get()

Status leveldb::TableCache::Get	(	const ReadOptions &	options,
		uint64_t	file_number,
		uint64_t	file_size,
		const Slice &	k,
		void *	arg,
		void(*)(void *, const Slice &, const Slice &)	handle_result
	)

Definition at line 105 of file table_cache.cc.

                                                                         {
  Cache::Handle* handle = NULL;
  Status s = FindTable(file_number, file_size, &handle);
  if (s.ok()) {
    Table* t = reinterpret_cast<TableAndFile*>(cache_->Value(handle))->table;
    s = t->InternalGet(options, k, arg, saver);
    cache_->Release(handle);
  }
  return s;
}

Here is the call graph for this function:

Here is the caller graph for this function:

NewIterator()

Iterator * leveldb::TableCache::NewIterator	(	const ReadOptions &	options,
		uint64_t	file_number,
		uint64_t	file_size,
		Table **	tableptr = NULL
	)

Definition at line 82 of file table_cache.cc.

                                                    {
  if (tableptr != NULL) {
    *tableptr = NULL;
  }

  Cache::Handle* handle = NULL;
  Status s = FindTable(file_number, file_size, &handle);
  if (!s.ok()) {
    return NewErrorIterator(s);
  }

  Table* table = reinterpret_cast<TableAndFile*>(cache_->Value(handle))->table;
  Iterator* result = table->NewIterator(options);
  result->RegisterCleanup(&UnrefEntry, cache_, handle);
  if (tableptr != NULL) {
    *tableptr = table;
  }
  return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

cache_

Cache* leveldb::TableCache::cache_

private

Definition at line 54 of file table_cache.h.

dbname_

const std::string leveldb::TableCache::dbname_

private

Definition at line 52 of file table_cache.h.

env_

Env* const leveldb::TableCache::env_

private

Definition at line 51 of file table_cache.h.

options_

const Options* leveldb::TableCache::options_

private

Definition at line 53 of file table_cache.h.

---

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

• db/table_cache.h
• db/table_cache.cc