Namespaces
	anonymous_namespace{bloom.cc}

	anonymous_namespace{cache.cc}

	anonymous_namespace{comparator.cc}

	anonymous_namespace{db_bench.cc}

	anonymous_namespace{db_bench_sqlite3.cc}

	anonymous_namespace{db_bench_tree_db.cc}

	anonymous_namespace{db_impl.cc}

	anonymous_namespace{db_iter.cc}

	anonymous_namespace{db_test.cc}

	anonymous_namespace{dumpfile.cc}

	anonymous_namespace{env_posix.cc}

	anonymous_namespace{fault_injection_test.cc}

	anonymous_namespace{iterator.cc}

	anonymous_namespace{leveldbutil.cc}

	anonymous_namespace{memenv.cc}

	anonymous_namespace{merger.cc}

	anonymous_namespace{repair.cc}

	anonymous_namespace{table_test.cc}

	anonymous_namespace{two_level_iterator.cc}

	anonymous_namespace{version_set.cc}

	anonymous_namespace{write_batch.cc}

	config

	crc32c

	log

	port

	test

Classes
class	Arena

class	ArenaTest

class	AutoCompactTest

class	Benchmark

class	Block

class	BlockBuilder

class	BlockConstructor

struct	BlockContents

class	BlockHandle

class	BloomTest

class	Cache

class	CacheTest

class	Coding

class	Compaction

class	Comparator

class	ConcurrentTest

class	Constructor

class	CorruptionTest

class	DB

class	DBConstructor

class	DBImpl

class	DBTest

class	Env

class	EnvPosixTest

class	EnvPosixTestHelper

class	EnvTest

class	EnvWrapper

class	FaultInjectionTest

class	FaultInjectionTestEnv

class	FileLock

struct	FileMetaData

class	FileNameTest

class	FilterBlockBuilder

class	FilterBlockReader

class	FilterBlockTest

class	FilterPolicy

class	FindFileTest

class	Footer

class	FormatTest

class	Harness

class	HASH

class	Histogram

class	InternalFilterPolicy

class	InternalKey

class	InternalKeyComparator

class	Issue200

class	Iterator

class	IteratorWrapper

class	KeyConvertingIterator

class	Logger

class	LookupKey

class	MemEnvTest

class	MemTable

class	MemTableConstructor

class	MemTableIterator

class	MemTableTest

class	ModelDB

class	MutexLock

struct	Options

struct	ParsedInternalKey

class	PosixLogger

class	Random

class	RandomAccessFile

struct	Range

struct	ReadOptions

class	RecoveryTest

class	SequentialFile

class	SkipList

class	SkipTest

class	Slice

class	Snapshot

class	SnapshotImpl

class	SnapshotList

class	SpecialEnv

struct	State

class	Status

class	StringSink

class	StringSource

class	Table

struct	TableAndFile

class	TableBuilder

class	TableCache

class	TableConstructor

class	TableTest

struct	TestArgs

class	TestHashFilter

class	TestState

class	TestWritableFile

class	Version

class	VersionEdit

class	VersionEditTest

class	VersionSet

class	WritableFile

class	WriteBatch

class	WriteBatchInternal

class	WriteBatchTest

struct	WriteOptions

Typedefs
typedef uint64_t	SequenceNumber

typedef uint64_t	Key

typedef std::map< std::string, std::string, STLLessThan >	KVMap

Enumerations
enum	ValueType { kTypeDeletion = 0x0, kTypeValue = 0x1 }

enum	FileType { kLogFile, kDBLockFile, kTableFile, kDescriptorFile, kCurrentFile, kTempFile, kInfoLogFile }

enum	Tag { kComparator = 1, kLogNumber = 2, kNextFileNumber = 3, kLastSequence = 4, kCompactPointer = 5, kDeletedFile = 6, kNewFile = 7, kPrevLogNumber = 9 }

enum	CompressionType { kNoCompression = 0x0, kSnappyCompression = 0x1 }

enum	TestType { TABLE_TEST, BLOCK_TEST, MEMTABLE_TEST, DB_TEST }

Functions
	TEST (AutoCompactTest, ReadAll)

	TEST (AutoCompactTest, ReadHalf)

Status	BuildTable (const std::string &dbname, Env env, const Options &options, TableCache table_cache, Iterator iter, FileMetaData meta)

	TEST (CorruptionTest, Recovery)

	TEST (CorruptionTest, RecoverWriteError)

	TEST (CorruptionTest, NewFileErrorDuringWrite)

	TEST (CorruptionTest, TableFile)

	TEST (CorruptionTest, TableFileRepair)

	TEST (CorruptionTest, TableFileIndexData)

	TEST (CorruptionTest, MissingDescriptor)

	TEST (CorruptionTest, SequenceNumberRecovery)

	TEST (CorruptionTest, CorruptedDescriptor)

	TEST (CorruptionTest, CompactionInputError)

	TEST (CorruptionTest, CompactionInputErrorParanoid)

	TEST (CorruptionTest, UnrelatedKeys)

template<class T , class V >
static void	ClipToRange (T *ptr, V minvalue, V maxvalue)

Options	SanitizeOptions (const std::string &dbname, const InternalKeyComparator icmp, const InternalFilterPolicy ipolicy, const Options &src)

Status	DestroyDB (const std::string &dbname, const Options &options)

Iterator *	NewDBIterator (DBImpl db, const Comparator user_key_comparator, Iterator *internal_iter, SequenceNumber sequence, uint32_t seed)

static std::string	RandomString (Random *rnd, int len)

	TEST (DBTest, Empty)

	TEST (DBTest, ReadWrite)

	TEST (DBTest, PutDeleteGet)

	TEST (DBTest, GetFromImmutableLayer)

	TEST (DBTest, GetFromVersions)

	TEST (DBTest, GetMemUsage)

	TEST (DBTest, GetSnapshot)

	TEST (DBTest, GetLevel0Ordering)

	TEST (DBTest, GetOrderedByLevels)

	TEST (DBTest, GetPicksCorrectFile)

	TEST (DBTest, GetEncountersEmptyLevel)

	TEST (DBTest, IterEmpty)

	TEST (DBTest, IterSingle)

	TEST (DBTest, IterMulti)

	TEST (DBTest, IterSmallAndLargeMix)

	TEST (DBTest, IterMultiWithDelete)

	TEST (DBTest, Recover)

	TEST (DBTest, RecoveryWithEmptyLog)

	TEST (DBTest, RecoverDuringMemtableCompaction)

static std::string	Key (int i)

	TEST (DBTest, MinorCompactionsHappen)

	TEST (DBTest, RecoverWithLargeLog)

	TEST (DBTest, CompactionsGenerateMultipleFiles)

	TEST (DBTest, RepeatedWritesToSameKey)

	TEST (DBTest, SparseMerge)

static bool	Between (uint64_t val, uint64_t low, uint64_t high)

	TEST (DBTest, ApproximateSizes)

	TEST (DBTest, ApproximateSizes_MixOfSmallAndLarge)

	TEST (DBTest, IteratorPinsRef)

	TEST (DBTest, Snapshot)

	TEST (DBTest, HiddenValuesAreRemoved)

	TEST (DBTest, DeletionMarkers1)

	TEST (DBTest, DeletionMarkers2)

	TEST (DBTest, OverlapInLevel0)

	TEST (DBTest, L0_CompactionBug_Issue44_a)

	TEST (DBTest, L0_CompactionBug_Issue44_b)

	TEST (DBTest, ComparatorCheck)

	TEST (DBTest, CustomComparator)

	TEST (DBTest, ManualCompaction)

	TEST (DBTest, DBOpen_Options)

	TEST (DBTest, Locking)

	TEST (DBTest, NoSpace)

	TEST (DBTest, NonWritableFileSystem)

	TEST (DBTest, WriteSyncError)

	TEST (DBTest, ManifestWriteError)

	TEST (DBTest, MissingSSTFile)

	TEST (DBTest, StillReadSST)

	TEST (DBTest, FilesDeletedAfterCompaction)

	TEST (DBTest, BloomFilter)

	TEST (DBTest, MultiThreaded)

static std::string	RandomKey (Random *rnd)

static bool	CompareIterators (int step, DB model, DB db, const Snapshot model_snap, const Snapshot db_snap)

	TEST (DBTest, Randomized)

std::string	MakeKey (unsigned int num)

void	BM_LogAndApply (int iters, int num_base_files)

static uint64_t	PackSequenceAndType (uint64_t seq, ValueType t)

void	AppendInternalKey (std::string *result, const ParsedInternalKey &key)

size_t	InternalKeyEncodingLength (const ParsedInternalKey &key)

bool	ParseInternalKey (const Slice &internal_key, ParsedInternalKey *result)

Slice	ExtractUserKey (const Slice &internal_key)

ValueType	ExtractValueType (const Slice &internal_key)

static std::string	IKey (const std::string &user_key, uint64_t seq, ValueType vt)

static std::string	Shorten (const std::string &s, const std::string &l)

static std::string	ShortSuccessor (const std::string &s)

static void	TestKey (const std::string &key, uint64_t seq, ValueType vt)

	TEST (FormatTest, InternalKey_EncodeDecode)

	TEST (FormatTest, InternalKeyShortSeparator)

	TEST (FormatTest, InternalKeyShortestSuccessor)

Status	DumpFile (Env env, const std::string &fname, WritableFile dst)

	TEST (FaultInjectionTest, FaultTestNoLogReuse)

	TEST (FaultInjectionTest, FaultTestWithLogReuse)

Status	WriteStringToFileSync (Env *env, const Slice &data, const std::string &fname)

static std::string	MakeFileName (const std::string &name, uint64_t number, const char *suffix)

std::string	LogFileName (const std::string &name, uint64_t number)

std::string	TableFileName (const std::string &name, uint64_t number)

std::string	SSTTableFileName (const std::string &name, uint64_t number)

std::string	DescriptorFileName (const std::string &dbname, uint64_t number)

std::string	CurrentFileName (const std::string &dbname)

std::string	LockFileName (const std::string &dbname)

std::string	TempFileName (const std::string &dbname, uint64_t number)

std::string	InfoLogFileName (const std::string &dbname)

std::string	OldInfoLogFileName (const std::string &dbname)

bool	ParseFileName (const std::string &fname, uint64_t number, FileType type)

Status	SetCurrentFile (Env *env, const std::string &dbname, uint64_t descriptor_number)

	TEST (FileNameTest, Parse)

	TEST (FileNameTest, Construction)

static Slice	GetLengthPrefixedSlice (const char *data)

static const char *	EncodeKey (std::string *scratch, const Slice &target)

	TEST (RecoveryTest, ManifestReused)

	TEST (RecoveryTest, LargeManifestCompacted)

	TEST (RecoveryTest, NoLogFiles)

	TEST (RecoveryTest, LogFileReuse)

	TEST (RecoveryTest, MultipleMemTables)

	TEST (RecoveryTest, MultipleLogFiles)

Status	RepairDB (const std::string &dbname, const Options &options)

	TEST (SkipTest, Empty)

	TEST (SkipTest, InsertAndLookup)

	TEST (SkipTest, ConcurrentWithoutThreads)

static void	ConcurrentReader (void *arg)

static void	RunConcurrent (int run)

	TEST (SkipTest, Concurrent1)

	TEST (SkipTest, Concurrent2)

	TEST (SkipTest, Concurrent3)

	TEST (SkipTest, Concurrent4)

	TEST (SkipTest, Concurrent5)

static void	DeleteEntry (const Slice &key, void *value)

static void	UnrefEntry (void arg1, void arg2)

static bool	GetInternalKey (Slice input, InternalKey dst)

static bool	GetLevel (Slice input, int level)

static void	TestEncodeDecode (const VersionEdit &edit)

	TEST (VersionEditTest, EncodeDecode)

static size_t	TargetFileSize (const Options *options)

static int64_t	MaxGrandParentOverlapBytes (const Options *options)

static int64_t	ExpandedCompactionByteSizeLimit (const Options *options)

static double	MaxBytesForLevel (const Options *options, int level)

static uint64_t	MaxFileSizeForLevel (const Options *options, int level)

static int64_t	TotalFileSize (const std::vector< FileMetaData * > &files)

int	FindFile (const InternalKeyComparator &icmp, const std::vector< FileMetaData * > &files, const Slice &key)

static bool	AfterFile (const Comparator ucmp, const Slice user_key, const FileMetaData *f)

static bool	BeforeFile (const Comparator ucmp, const Slice user_key, const FileMetaData *f)

bool	SomeFileOverlapsRange (const InternalKeyComparator &icmp, bool disjoint_sorted_files, const std::vector< FileMetaData * > &files, const Slice smallest_user_key, const Slice largest_user_key)

static Iterator *	GetFileIterator (void *arg, const ReadOptions &options, const Slice &file_value)

static void	SaveValue (void *arg, const Slice &ikey, const Slice &v)

static bool	NewestFirst (FileMetaData a, FileMetaData b)

	TEST (FindFileTest, Empty)

	TEST (FindFileTest, Single)

	TEST (FindFileTest, Multiple)

	TEST (FindFileTest, MultipleNullBoundaries)

	TEST (FindFileTest, OverlapSequenceChecks)

	TEST (FindFileTest, OverlappingFiles)

static std::string	PrintContents (WriteBatch *b)

	TEST (WriteBatchTest, Empty)

	TEST (WriteBatchTest, Multiple)

	TEST (WriteBatchTest, Corruption)

	TEST (WriteBatchTest, Append)

Env *	NewMemEnv (Env *base_env)

	TEST (MemEnvTest, Basics)

	TEST (MemEnvTest, ReadWrite)

	TEST (MemEnvTest, Locks)

	TEST (MemEnvTest, Misc)

	TEST (MemEnvTest, LargeWrite)

	TEST (MemEnvTest, DBTest)

Cache *	NewLRUCache (size_t capacity)

const Comparator *	BytewiseComparator ()

void	Log (Logger info_log, const char format,...)

Status	WriteStringToFile (Env *env, const Slice &data, const std::string &fname)

Status	ReadFileToString (Env env, const std::string &fname, std::string data)

const FilterPolicy *	NewBloomFilterPolicy (int bits_per_key)

Iterator *	NewEmptyIterator ()

Iterator *	NewErrorIterator (const Status &status)

bool	operator== (const Slice &x, const Slice &y)

bool	operator!= (const Slice &x, const Slice &y)

	TEST (Issue200, Test)

static const char *	DecodeEntry (const char p, const char limit, uint32_t shared, uint32_t non_shared, uint32_t *value_length)

	TEST (FilterBlockTest, EmptyBuilder)

	TEST (FilterBlockTest, SingleChunk)

	TEST (FilterBlockTest, MultiChunk)

Status	ReadBlock (RandomAccessFile file, const ReadOptions &options, const BlockHandle &handle, BlockContents result)

Iterator *	NewMergingIterator (const Comparator cmp, Iterator *list, int n)

static void	DeleteBlock (void arg, void ignored)

static void	DeleteCachedBlock (const Slice &key, void *value)

static void	ReleaseBlock (void arg, void h)

static std::string	Reverse (const Slice &key)

static void	Increment (const Comparator cmp, std::string key)

	TEST (Harness, Empty)

	TEST (Harness, ZeroRestartPointsInBlock)

	TEST (Harness, SimpleEmptyKey)

	TEST (Harness, SimpleSingle)

	TEST (Harness, SimpleMulti)

	TEST (Harness, SimpleSpecialKey)

	TEST (Harness, Randomized)

	TEST (Harness, RandomizedLongDB)

	TEST (MemTableTest, Simple)

static bool	Between (uint64_t val, uint64_t low, uint64_t high)

	TEST (TableTest, ApproximateOffsetOfPlain)

static bool	SnappyCompressionSupported ()

	TEST (TableTest, ApproximateOffsetOfCompressed)

Iterator *	NewTwoLevelIterator (Iterator index_iter, BlockFunction block_function, void arg, const ReadOptions &options)

Iterator *	NewTwoLevelIterator (Iterator index_iter, Iterator (block_function)(void arg, const ReadOptions &options, const Slice &index_value), void *arg, const ReadOptions &options)

	TEST (ArenaTest, Empty)

	TEST (ArenaTest, Simple)

static Slice	Key (int i, char *buffer)

	TEST (BloomTest, EmptyFilter)

	TEST (BloomTest, Small)

static int	NextLength (int length)

	TEST (BloomTest, VaryingLengths)

static std::string	EncodeKey (int k)

static int	DecodeKey (const Slice &k)

static void *	EncodeValue (uintptr_t v)

static int	DecodeValue (void *v)

	TEST (CacheTest, HitAndMiss)

	TEST (CacheTest, Erase)

	TEST (CacheTest, EntriesArePinned)

	TEST (CacheTest, EvictionPolicy)

	TEST (CacheTest, UseExceedsCacheSize)

	TEST (CacheTest, HeavyEntries)

	TEST (CacheTest, NewId)

	TEST (CacheTest, Prune)

void	EncodeFixed32 (char *buf, uint32_t value)

void	EncodeFixed64 (char *buf, uint64_t value)

void	PutFixed32 (std::string *dst, uint32_t value)

void	PutFixed64 (std::string *dst, uint64_t value)

char *	EncodeVarint32 (char *dst, uint32_t v)

void	PutVarint32 (std::string *dst, uint32_t v)

char *	EncodeVarint64 (char *dst, uint64_t v)

void	PutVarint64 (std::string *dst, uint64_t v)

void	PutLengthPrefixedSlice (std::string *dst, const Slice &value)

int	VarintLength (uint64_t v)

const char *	GetVarint32PtrFallback (const char p, const char limit, uint32_t *value)

bool	GetVarint32 (Slice input, uint32_t value)

const char *	GetVarint64Ptr (const char p, const char limit, uint64_t *value)

bool	GetVarint64 (Slice input, uint64_t value)

const char *	GetLengthPrefixedSlice (const char p, const char limit, Slice *result)

bool	GetLengthPrefixedSlice (Slice input, Slice result)

const char *	GetVarint32Ptr (const char p, const char limit, uint32_t *v)

uint32_t	DecodeFixed32 (const char *ptr)

uint64_t	DecodeFixed64 (const char *ptr)

	TEST (Coding, Fixed32)

	TEST (Coding, Fixed64)

	TEST (Coding, EncodingOutput)

	TEST (Coding, Varint32)

	TEST (Coding, Varint64)

	TEST (Coding, Varint32Overflow)

	TEST (Coding, Varint32Truncation)

	TEST (Coding, Varint64Overflow)

	TEST (Coding, Varint64Truncation)

	TEST (Coding, Strings)

static void	InitModule ()

static Status	DoWriteStringToFile (Env *env, const Slice &data, const std::string &fname, bool should_sync)

static void	InitDefaultEnv ()

	TEST (EnvPosixTest, TestOpenOnRead)

static void	SetBool (void *ptr)

	TEST (EnvTest, RunImmediately)

	TEST (EnvTest, RunMany)

static void	ThreadBody (void *arg)

	TEST (EnvTest, StartThread)

uint32_t	Hash (const char *data, size_t n, uint32_t seed)

	TEST (HASH, SignedUnsignedIssue)

void	AppendNumberTo (std::string *str, uint64_t num)

void	AppendEscapedStringTo (std::string *str, const Slice &value)

std::string	NumberToString (uint64_t num)

std::string	EscapeString (const Slice &value)

bool	ConsumeDecimalNumber (Slice in, uint64_t val)

Variables
static const int	kValueSize = 200 * 1024

static const int	kTotalSize = 100 * 1024 * 1024

static const int	kCount = kTotalSize / kValueSize

static const int	kValueSize = 1000

const int	kNumNonTableCacheFiles = 10

static const ValueType	kValueTypeForSeek = kTypeValue

static const SequenceNumber	kMaxSequenceNumber

static const int	kValueSize = 1000

static const int	kMaxNumValues = 2000

static const size_t	kNumIterations = 3

static const size_t	kHeader = 12

static const int	kMajorVersion = 1

static const int	kMinorVersion = 20

static const size_t	kFilterBaseLg = 11

static const size_t	kFilterBase = 1 << kFilterBaseLg

static const uint64_t	kTableMagicNumber = 0xdb4775248b80fb57ull

static const size_t	kBlockTrailerSize = 5

static ReverseKeyComparator	reverse_key_comparator

static const TestArgs	kTestArgList []

static const int	kNumTestArgs = sizeof(kTestArgList) / sizeof(kTestArgList[0])

static const int	kBlockSize = 4096

static const int	kVerbose = 1

static port::OnceType	once = LEVELDB_ONCE_INIT

static const Comparator *	bytewise

static pthread_once_t	once = PTHREAD_ONCE_INIT

static Env *	default_env

static const int	kDelayMicros = 100000

static const int	kReadOnlyFileLimit = 4

static const int	kMMapLimit = 4

static const int	kDelayMicros = 100000

static const int	kReadOnlyFileLimit = 4

static const int	kMMapLimit = 4

Typedef Documentation

◆ Key

typedef uint64_t leveldb::Key

◆ KVMap

typedef std::map<std::string, std::string, STLLessThan> leveldb::KVMap

◆ SequenceNumber

typedef uint64_t leveldb::SequenceNumber

Enumeration Type Documentation

◆ CompressionType

enum leveldb::CompressionType

Enumerator
kNoCompression
kSnappyCompression

◆ FileType

enum leveldb::FileType

Enumerator
kLogFile
kDBLockFile
kTableFile
kDescriptorFile
kCurrentFile
kTempFile
kInfoLogFile

◆ Tag

enum leveldb::Tag

Enumerator
kComparator
kLogNumber
kNextFileNumber
kLastSequence
kCompactPointer
kDeletedFile
kNewFile
kPrevLogNumber

◆ TestType

enum leveldb::TestType

Enumerator
TABLE_TEST
BLOCK_TEST
MEMTABLE_TEST
DB_TEST

◆ ValueType

enum leveldb::ValueType

Enumerator
kTypeDeletion
kTypeValue

Function Documentation

◆ AfterFile()

static bool leveldb::AfterFile	(	const Comparator *	ucmp,
		const Slice *	user_key,
		const FileMetaData *	f
	)

static

◆ AppendEscapedStringTo()

void leveldb::AppendEscapedStringTo	(	std::string *	str,
		const Slice &	value
	)

◆ AppendInternalKey()

void leveldb::AppendInternalKey	(	std::string *	result,
		const ParsedInternalKey &	key
	)

◆ AppendNumberTo()

void leveldb::AppendNumberTo	(	std::string *	str,
		uint64_t	num
	)

◆ BeforeFile()

static bool leveldb::BeforeFile	(	const Comparator *	ucmp,
		const Slice *	user_key,
		const FileMetaData *	f
	)

static

◆ Between() [1/2]

static bool leveldb::Between	(	uint64_t	val,
		uint64_t	low,
		uint64_t	high
	)

static

◆ Between() [2/2]

static bool leveldb::Between	(	uint64_t	val,
		uint64_t	low,
		uint64_t	high
	)

static

◆ BM_LogAndApply()

void leveldb::BM_LogAndApply	(	int	iters,
		int	num_base_files
	)

◆ BuildTable()

Status leveldb::BuildTable	(	const std::string &	dbname,
		Env *	env,
		const Options &	options,
		TableCache *	table_cache,
		Iterator *	iter,
		FileMetaData *	meta
	)

◆ BytewiseComparator()

const Comparator * leveldb::BytewiseComparator ( )

◆ ClipToRange()

template<class T , class V >

static void leveldb::ClipToRange	(	T *	ptr,
		V	minvalue,
		V	maxvalue
	)

static

◆ CompareIterators()

static bool leveldb::CompareIterators	(	int	step,
		DB *	model,
		DB *	db,
		const Snapshot *	model_snap,
		const Snapshot *	db_snap
	)

static

◆ ConcurrentReader()

static void leveldb::ConcurrentReader ( void * arg )

static

◆ ConsumeDecimalNumber()

bool leveldb::ConsumeDecimalNumber	(	Slice *	in,
		uint64_t *	val
	)

◆ CurrentFileName()

std::string leveldb::CurrentFileName ( const std::string & dbname )

◆ DecodeEntry()

static const char* leveldb::DecodeEntry	(	const char *	p,
		const char *	limit,
		uint32_t *	shared,
		uint32_t *	non_shared,
		uint32_t *	value_length
	)

inlinestatic

◆ DecodeFixed32()

uint32_t leveldb::DecodeFixed32 ( const char * ptr )

inline

◆ DecodeFixed64()

uint64_t leveldb::DecodeFixed64 ( const char * ptr )

inline

◆ DecodeKey()

static int leveldb::DecodeKey ( const Slice & k )

static

◆ DecodeValue()

static int leveldb::DecodeValue ( void * v )

static

◆ DeleteBlock()

static void leveldb::DeleteBlock	(	void *	arg,
		void *	ignored
	)

static

◆ DeleteCachedBlock()

static void leveldb::DeleteCachedBlock	(	const Slice &	key,
		void *	value
	)

static

◆ DeleteEntry()

static void leveldb::DeleteEntry	(	const Slice &	key,
		void *	value
	)

static

◆ DescriptorFileName()

std::string leveldb::DescriptorFileName	(	const std::string &	dbname,
		uint64_t	number
	)

◆ DestroyDB()

Status leveldb::DestroyDB	(	const std::string &	dbname,
		const Options &	options
	)

◆ DoWriteStringToFile()

static Status leveldb::DoWriteStringToFile	(	Env *	env,
		const Slice &	data,
		const std::string &	fname,
		bool	should_sync
	)

static

◆ DumpFile()

Status leveldb::DumpFile	(	Env *	env,
		const std::string &	fname,
		WritableFile *	dst
	)

◆ EncodeFixed32()

void leveldb::EncodeFixed32	(	char *	buf,
		uint32_t	value
	)

◆ EncodeFixed64()

void leveldb::EncodeFixed64	(	char *	buf,
		uint64_t	value
	)

◆ EncodeKey() [1/2]

static std::string leveldb::EncodeKey ( int k )

static

◆ EncodeKey() [2/2]

static const char* leveldb::EncodeKey	(	std::string *	scratch,
		const Slice &	target
	)

static

◆ EncodeValue()

static void* leveldb::EncodeValue ( uintptr_t v )

static

◆ EncodeVarint32()

char * leveldb::EncodeVarint32	(	char *	dst,
		uint32_t	v
	)

◆ EncodeVarint64()

char * leveldb::EncodeVarint64	(	char *	dst,
		uint64_t	v
	)

◆ EscapeString()

std::string leveldb::EscapeString ( const Slice & value )

◆ ExpandedCompactionByteSizeLimit()

static int64_t leveldb::ExpandedCompactionByteSizeLimit ( const Options * options )

static

◆ ExtractUserKey()

Slice leveldb::ExtractUserKey ( const Slice & internal_key )

inline

◆ ExtractValueType()

ValueType leveldb::ExtractValueType ( const Slice & internal_key )

inline

◆ FindFile()

int leveldb::FindFile	(	const InternalKeyComparator &	icmp,
		const std::vector< FileMetaData * > &	files,
		const Slice &	key
	)

◆ GetFileIterator()

static Iterator* leveldb::GetFileIterator	(	void *	arg,
		const ReadOptions &	options,
		const Slice &	file_value
	)

static

◆ GetInternalKey()

static bool leveldb::GetInternalKey	(	Slice *	input,
		InternalKey *	dst
	)

static

◆ GetLengthPrefixedSlice() [1/3]

static Slice leveldb::GetLengthPrefixedSlice ( const char * data )

static

◆ GetLengthPrefixedSlice() [2/3]

const char* leveldb::GetLengthPrefixedSlice	(	const char *	p,
		const char *	limit,
		Slice *	result
	)

◆ GetLengthPrefixedSlice() [3/3]

bool leveldb::GetLengthPrefixedSlice	(	Slice *	input,
		Slice *	result
	)

◆ GetLevel()

static bool leveldb::GetLevel	(	Slice *	input,
		int *	level
	)

static

◆ GetVarint32()

bool leveldb::GetVarint32	(	Slice *	input,
		uint32_t *	value
	)

◆ GetVarint32Ptr()

const char * leveldb::GetVarint32Ptr	(	const char *	p,
		const char *	limit,
		uint32_t *	v
	)

inline

◆ GetVarint32PtrFallback()

const char * leveldb::GetVarint32PtrFallback	(	const char *	p,
		const char *	limit,
		uint32_t *	value
	)

◆ GetVarint64()

bool leveldb::GetVarint64	(	Slice *	input,
		uint64_t *	value
	)

◆ GetVarint64Ptr()

const char * leveldb::GetVarint64Ptr	(	const char *	p,
		const char *	limit,
		uint64_t *	value
	)

◆ Hash()

uint32_t leveldb::Hash	(	const char *	data,
		size_t	n,
		uint32_t	seed
	)

◆ IKey()

static std::string leveldb::IKey	(	const std::string &	user_key,
		uint64_t	seq,
		ValueType	vt
	)

static

◆ Increment()

static void leveldb::Increment	(	const Comparator *	cmp,
		std::string *	key
	)

static

◆ InfoLogFileName()

std::string leveldb::InfoLogFileName ( const std::string & dbname )

◆ InitDefaultEnv()

static void leveldb::InitDefaultEnv ( )

static

◆ InitModule()

static void leveldb::InitModule ( )

static

◆ InternalKeyEncodingLength()

size_t leveldb::InternalKeyEncodingLength ( const ParsedInternalKey & key )

inline

◆ Key() [1/2]

static Slice leveldb::Key	(	int	i,
		char *	buffer
	)

static

◆ Key() [2/2]

static std::string leveldb::Key ( int i )

static

◆ LockFileName()

std::string leveldb::LockFileName ( const std::string & dbname )

◆ Log()

void leveldb::Log	(	Logger *	info_log,
		const char *	format,
			...
	)

◆ LogFileName()

std::string leveldb::LogFileName	(	const std::string &	name,
		uint64_t	number
	)

◆ MakeFileName()

static std::string leveldb::MakeFileName	(	const std::string &	name,
		uint64_t	number,
		const char *	suffix
	)

static

◆ MakeKey()

std::string leveldb::MakeKey ( unsigned int num )

◆ MaxBytesForLevel()

static double leveldb::MaxBytesForLevel	(	const Options *	options,
		int	level
	)

static

◆ MaxFileSizeForLevel()

static uint64_t leveldb::MaxFileSizeForLevel	(	const Options *	options,
		int	level
	)

static

◆ MaxGrandParentOverlapBytes()

static int64_t leveldb::MaxGrandParentOverlapBytes ( const Options * options )

static

◆ NewBloomFilterPolicy()

const FilterPolicy * leveldb::NewBloomFilterPolicy ( int bits_per_key )

◆ NewDBIterator()

Iterator * leveldb::NewDBIterator	(	DBImpl *	db,
		const Comparator *	user_key_comparator,
		Iterator *	internal_iter,
		SequenceNumber	sequence,
		uint32_t	seed
	)

◆ NewEmptyIterator()

Iterator * leveldb::NewEmptyIterator ( )

◆ NewErrorIterator()

Iterator * leveldb::NewErrorIterator ( const Status & status )

◆ NewestFirst()

static bool leveldb::NewestFirst	(	FileMetaData *	a,
		FileMetaData *	b
	)

static

◆ NewLRUCache()

Cache * leveldb::NewLRUCache ( size_t capacity )

◆ NewMemEnv()

Env * leveldb::NewMemEnv ( Env * base_env )

◆ NewMergingIterator()

Iterator * leveldb::NewMergingIterator	(	const Comparator *	cmp,
		Iterator **	list,
		int	n
	)

◆ NewTwoLevelIterator() [1/2]

Iterator* leveldb::NewTwoLevelIterator	(	Iterator *	index_iter,
		Iterator ()(void *arg, const ReadOptions &options, const Slice &index_value)	block_function,
		void *	arg,
		const ReadOptions &	options
	)

◆ NewTwoLevelIterator() [2/2]

Iterator* leveldb::NewTwoLevelIterator	(	Iterator *	index_iter,
		BlockFunction	block_function,
		void *	arg,
		const ReadOptions &	options
	)

◆ NextLength()

static int leveldb::NextLength ( int length )

static

◆ NumberToString()

std::string leveldb::NumberToString ( uint64_t num )

◆ OldInfoLogFileName()

std::string leveldb::OldInfoLogFileName ( const std::string & dbname )

◆ operator!=()

bool leveldb::operator!=	(	const Slice &	x,
		const Slice &	y
	)

inline

◆ operator==()

bool leveldb::operator==	(	const Slice &	x,
		const Slice &	y
	)

inline

◆ PackSequenceAndType()

static uint64_t leveldb::PackSequenceAndType	(	uint64_t	seq,
		ValueType	t
	)

static

◆ ParseFileName()

bool leveldb::ParseFileName	(	const std::string &	fname,
		uint64_t *	number,
		FileType *	type
	)

◆ ParseInternalKey()

bool leveldb::ParseInternalKey	(	const Slice &	internal_key,
		ParsedInternalKey *	result
	)

inline

◆ PrintContents()

static std::string leveldb::PrintContents ( WriteBatch * b )

static

◆ PutFixed32()

void leveldb::PutFixed32	(	std::string *	dst,
		uint32_t	value
	)

◆ PutFixed64()

void leveldb::PutFixed64	(	std::string *	dst,
		uint64_t	value
	)

◆ PutLengthPrefixedSlice()

void leveldb::PutLengthPrefixedSlice	(	std::string *	dst,
		const Slice &	value
	)

◆ PutVarint32()

void leveldb::PutVarint32	(	std::string *	dst,
		uint32_t	v
	)

◆ PutVarint64()

void leveldb::PutVarint64	(	std::string *	dst,
		uint64_t	v
	)

◆ RandomKey()

static std::string leveldb::RandomKey ( Random * rnd )

static

◆ RandomString()

static std::string leveldb::RandomString	(	Random *	rnd,
		int	len
	)

static

◆ ReadBlock()

Status leveldb::ReadBlock	(	RandomAccessFile *	file,
		const ReadOptions &	options,
		const BlockHandle &	handle,
		BlockContents *	result
	)

◆ ReadFileToString()

Status leveldb::ReadFileToString	(	Env *	env,
		const std::string &	fname,
		std::string *	data
	)

◆ ReleaseBlock()

static void leveldb::ReleaseBlock	(	void *	arg,
		void *	h
	)

static

◆ RepairDB()

Status leveldb::RepairDB	(	const std::string &	dbname,
		const Options &	options
	)

◆ Reverse()

static std::string leveldb::Reverse ( const Slice & key )

static

◆ RunConcurrent()

static void leveldb::RunConcurrent ( int run )

static

◆ SanitizeOptions()

Options leveldb::SanitizeOptions	(	const std::string &	dbname,
		const InternalKeyComparator *	icmp,
		const InternalFilterPolicy *	ipolicy,
		const Options &	src
	)

◆ SaveValue()

static void leveldb::SaveValue	(	void *	arg,
		const Slice &	ikey,
		const Slice &	v
	)

static

◆ SetBool()

static void leveldb::SetBool ( void * ptr )

static

◆ SetCurrentFile()

Status leveldb::SetCurrentFile	(	Env *	env,
		const std::string &	dbname,
		uint64_t	descriptor_number
	)

◆ Shorten()

static std::string leveldb::Shorten	(	const std::string &	s,
		const std::string &	l
	)

static

◆ ShortSuccessor()

static std::string leveldb::ShortSuccessor ( const std::string & s )

static

◆ SnappyCompressionSupported()

static bool leveldb::SnappyCompressionSupported ( )

static

◆ SomeFileOverlapsRange()

bool leveldb::SomeFileOverlapsRange	(	const InternalKeyComparator &	icmp,
		bool	disjoint_sorted_files,
		const std::vector< FileMetaData * > &	files,
		const Slice *	smallest_user_key,
		const Slice *	largest_user_key
	)

◆ SSTTableFileName()

std::string leveldb::SSTTableFileName	(	const std::string &	name,
		uint64_t	number
	)

◆ TableFileName()

std::string leveldb::TableFileName	(	const std::string &	name,
		uint64_t	number
	)

◆ TargetFileSize()

static size_t leveldb::TargetFileSize ( const Options * options )

static

◆ TempFileName()

std::string leveldb::TempFileName	(	const std::string &	dbname,
		uint64_t	number
	)

◆ TEST() [1/144]

leveldb::TEST	(	HASH	,
		SignedUnsignedIssue
	)

◆ TEST() [2/144]

leveldb::TEST	(	Coding	,
		Fixed32
	)

◆ TEST() [3/144]

leveldb::TEST	(	ArenaTest	,
		Empty
	)

◆ TEST() [4/144]

leveldb::TEST	(	Issue200	,
		Test
	)

◆ TEST() [5/144]

leveldb::TEST	(	FileNameTest	,
		Parse
	)

◆ TEST() [6/144]

leveldb::TEST	(	ArenaTest	,
		Simple
	)

◆ TEST() [7/144]

leveldb::TEST	(	VersionEditTest	,
		EncodeDecode
	)

◆ TEST() [8/144]

leveldb::TEST	(	Coding	,
		Fixed64
	)

◆ TEST() [9/144]

leveldb::TEST	(	MemEnvTest	,
		Basics
	)

◆ TEST() [10/144]

leveldb::TEST	(	EnvPosixTest	,
		TestOpenOnRead
	)

◆ TEST() [11/144]

leveldb::TEST	(	EnvTest	,
		RunImmediately
	)

◆ TEST() [12/144]

leveldb::TEST	(	SkipTest	,
		Empty
	)

◆ TEST() [13/144]

leveldb::TEST	(	EnvTest	,
		RunMany
	)

◆ TEST() [14/144]

leveldb::TEST	(	FilterBlockTest	,
		EmptyBuilder
	)

◆ TEST() [15/144]

leveldb::TEST	(	SkipTest	,
		InsertAndLookup
	)

◆ TEST() [16/144]

leveldb::TEST	(	FormatTest	,
		InternalKey_EncodeDecode
	)

◆ TEST() [17/144]

leveldb::TEST	(	FindFileTest	,
		Empty
	)

◆ TEST() [18/144]

leveldb::TEST	(	FilterBlockTest	,
		SingleChunk
	)

◆ TEST() [19/144]

leveldb::TEST	(	Coding	,
		EncodingOutput
	)

◆ TEST() [20/144]

leveldb::TEST	(	WriteBatchTest	,
		Empty
	)

◆ TEST() [21/144]

leveldb::TEST	(	FindFileTest	,
		Single
	)

◆ TEST() [22/144]

leveldb::TEST	(	WriteBatchTest	,
		Multiple
	)

◆ TEST() [23/144]

leveldb::TEST	(	FormatTest	,
		InternalKeyShortSeparator
	)

◆ TEST() [24/144]

leveldb::TEST	(	CacheTest	,
		HitAndMiss
	)

◆ TEST() [25/144]

leveldb::TEST	(	FilterBlockTest	,
		MultiChunk
	)

◆ TEST() [26/144]

leveldb::TEST	(	WriteBatchTest	,
		Corruption
	)

◆ TEST() [27/144]

leveldb::TEST	(	FileNameTest	,
		Construction
	)

◆ TEST() [28/144]

leveldb::TEST	(	Coding	,
		Varint32
	)

◆ TEST() [29/144]

leveldb::TEST	(	EnvTest	,
		StartThread
	)

◆ TEST() [30/144]

leveldb::TEST	(	BloomTest	,
		EmptyFilter
	)

◆ TEST() [31/144]

leveldb::TEST	(	FindFileTest	,
		Multiple
	)

◆ TEST() [32/144]

leveldb::TEST	(	WriteBatchTest	,
		Append
	)

◆ TEST() [33/144]

leveldb::TEST	(	BloomTest	,
		Small
	)

◆ TEST() [34/144]

leveldb::TEST	(	MemEnvTest	,
		ReadWrite
	)

◆ TEST() [35/144]

leveldb::TEST	(	CacheTest	,
		Erase
	)

◆ TEST() [36/144]

leveldb::TEST	(	Coding	,
		Varint64
	)

◆ TEST() [37/144]

leveldb::TEST	(	FormatTest	,
		InternalKeyShortestSuccessor
	)

◆ TEST() [38/144]

leveldb::TEST	(	AutoCompactTest	,
		ReadAll
	)

◆ TEST() [39/144]

leveldb::TEST	(	AutoCompactTest	,
		ReadHalf
	)

◆ TEST() [40/144]

leveldb::TEST	(	CacheTest	,
		EntriesArePinned
	)

◆ TEST() [41/144]

leveldb::TEST	(	BloomTest	,
		VaryingLengths
	)

◆ TEST() [42/144]

leveldb::TEST	(	FindFileTest	,
		MultipleNullBoundaries
	)

◆ TEST() [43/144]

leveldb::TEST	(	Coding	,
		Varint32Overflow
	)

◆ TEST() [44/144]

leveldb::TEST	(	MemEnvTest	,
		Locks
	)

◆ TEST() [45/144]

leveldb::TEST	(	CacheTest	,
		EvictionPolicy
	)

◆ TEST() [46/144]

leveldb::TEST	(	Coding	,
		Varint32Truncation
	)

◆ TEST() [47/144]

leveldb::TEST	(	MemEnvTest	,
		Misc
	)

◆ TEST() [48/144]

leveldb::TEST	(	FindFileTest	,
		OverlapSequenceChecks
	)

◆ TEST() [49/144]

leveldb::TEST	(	Coding	,
		Varint64Overflow
	)

◆ TEST() [50/144]

leveldb::TEST	(	FindFileTest	,
		OverlappingFiles
	)

◆ TEST() [51/144]

leveldb::TEST	(	CacheTest	,
		UseExceedsCacheSize
	)

◆ TEST() [52/144]

leveldb::TEST	(	RecoveryTest	,
		ManifestReused
	)

◆ TEST() [53/144]

leveldb::TEST	(	Coding	,
		Varint64Truncation
	)

◆ TEST() [54/144]

leveldb::TEST	(	MemEnvTest	,
		LargeWrite
	)

◆ TEST() [55/144]

leveldb::TEST	(	Coding	,
		Strings
	)

◆ TEST() [56/144]

leveldb::TEST	(	RecoveryTest	,
		LargeManifestCompacted
	)

◆ TEST() [57/144]

leveldb::TEST	(	CacheTest	,
		HeavyEntries
	)

◆ TEST() [58/144]

leveldb::TEST	(	MemEnvTest	,
		DBTest
	)

◆ TEST() [59/144]

leveldb::TEST	(	CorruptionTest	,
		Recovery
	)

◆ TEST() [60/144]

leveldb::TEST	(	CacheTest	,
		NewId
	)

◆ TEST() [61/144]

leveldb::TEST	(	RecoveryTest	,
		NoLogFiles
	)

◆ TEST() [62/144]

leveldb::TEST	(	CacheTest	,
		Prune
	)

◆ TEST() [63/144]

leveldb::TEST	(	CorruptionTest	,
		RecoverWriteError
	)

◆ TEST() [64/144]

leveldb::TEST	(	RecoveryTest	,
		LogFileReuse
	)

◆ TEST() [65/144]

leveldb::TEST	(	CorruptionTest	,
		NewFileErrorDuringWrite
	)

◆ TEST() [66/144]

leveldb::TEST	(	CorruptionTest	,
		TableFile
	)

◆ TEST() [67/144]

leveldb::TEST	(	RecoveryTest	,
		MultipleMemTables
	)

◆ TEST() [68/144]

leveldb::TEST	(	CorruptionTest	,
		TableFileRepair
	)

◆ TEST() [69/144]

leveldb::TEST	(	CorruptionTest	,
		TableFileIndexData
	)

◆ TEST() [70/144]

leveldb::TEST	(	CorruptionTest	,
		MissingDescriptor
	)

◆ TEST() [71/144]

leveldb::TEST	(	RecoveryTest	,
		MultipleLogFiles
	)

◆ TEST() [72/144]

leveldb::TEST	(	CorruptionTest	,
		SequenceNumberRecovery
	)

◆ TEST() [73/144]

leveldb::TEST	(	SkipTest	,
		ConcurrentWithoutThreads
	)

◆ TEST() [74/144]

leveldb::TEST	(	CorruptionTest	,
		CorruptedDescriptor
	)

◆ TEST() [75/144]

leveldb::TEST	(	CorruptionTest	,
		CompactionInputError
	)

◆ TEST() [76/144]

leveldb::TEST	(	CorruptionTest	,
		CompactionInputErrorParanoid
	)

◆ TEST() [77/144]

leveldb::TEST	(	CorruptionTest	,
		UnrelatedKeys
	)

◆ TEST() [78/144]

leveldb::TEST	(	SkipTest	,
		Concurrent1
	)

◆ TEST() [79/144]

leveldb::TEST	(	SkipTest	,
		Concurrent2
	)

◆ TEST() [80/144]

leveldb::TEST	(	SkipTest	,
		Concurrent3
	)

◆ TEST() [81/144]

leveldb::TEST	(	SkipTest	,
		Concurrent4
	)

◆ TEST() [82/144]

leveldb::TEST	(	SkipTest	,
		Concurrent5
	)

◆ TEST() [83/144]

leveldb::TEST	(	DBTest	,
		Empty
	)

◆ TEST() [84/144]

leveldb::TEST	(	DBTest	,
		ReadWrite
	)

◆ TEST() [85/144]

leveldb::TEST	(	DBTest	,
		PutDeleteGet
	)

◆ TEST() [86/144]

leveldb::TEST	(	DBTest	,
		GetFromImmutableLayer
	)

◆ TEST() [87/144]

leveldb::TEST	(	FaultInjectionTest	,
		FaultTestNoLogReuse
	)

◆ TEST() [88/144]

leveldb::TEST	(	FaultInjectionTest	,
		FaultTestWithLogReuse
	)

◆ TEST() [89/144]

leveldb::TEST	(	DBTest	,
		GetFromVersions
	)

◆ TEST() [90/144]

leveldb::TEST	(	DBTest	,
		GetMemUsage
	)

◆ TEST() [91/144]

leveldb::TEST	(	DBTest	,
		GetSnapshot
	)

◆ TEST() [92/144]

leveldb::TEST	(	DBTest	,
		GetLevel0Ordering
	)

◆ TEST() [93/144]

leveldb::TEST	(	DBTest	,
		GetOrderedByLevels
	)

◆ TEST() [94/144]

leveldb::TEST	(	DBTest	,
		GetPicksCorrectFile
	)

◆ TEST() [95/144]

leveldb::TEST	(	DBTest	,
		GetEncountersEmptyLevel
	)

◆ TEST() [96/144]

leveldb::TEST	(	Harness	,
		Empty
	)

◆ TEST() [97/144]

leveldb::TEST	(	Harness	,
		ZeroRestartPointsInBlock
	)

◆ TEST() [98/144]

leveldb::TEST	(	DBTest	,
		IterEmpty
	)

◆ TEST() [99/144]

leveldb::TEST	(	Harness	,
		SimpleEmptyKey
	)

◆ TEST() [100/144]

leveldb::TEST	(	Harness	,
		SimpleSingle
	)

◆ TEST() [101/144]

leveldb::TEST	(	DBTest	,
		IterSingle
	)

◆ TEST() [102/144]

leveldb::TEST	(	Harness	,
		SimpleMulti
	)

◆ TEST() [103/144]

leveldb::TEST	(	Harness	,
		SimpleSpecialKey
	)

◆ TEST() [104/144]

leveldb::TEST	(	Harness	,
		Randomized
	)

◆ TEST() [105/144]

leveldb::TEST	(	DBTest	,
		IterMulti
	)

◆ TEST() [106/144]

leveldb::TEST	(	Harness	,
		RandomizedLongDB
	)

◆ TEST() [107/144]

leveldb::TEST	(	MemTableTest	,
		Simple
	)

◆ TEST() [108/144]

leveldb::TEST	(	TableTest	,
		ApproximateOffsetOfPlain
	)

◆ TEST() [109/144]

leveldb::TEST	(	DBTest	,
		IterSmallAndLargeMix
	)

◆ TEST() [110/144]

leveldb::TEST	(	TableTest	,
		ApproximateOffsetOfCompressed
	)

◆ TEST() [111/144]

leveldb::TEST	(	DBTest	,
		IterMultiWithDelete
	)

◆ TEST() [112/144]

leveldb::TEST	(	DBTest	,
		Recover
	)

◆ TEST() [113/144]

leveldb::TEST	(	DBTest	,
		RecoveryWithEmptyLog
	)

◆ TEST() [114/144]

leveldb::TEST	(	DBTest	,
		RecoverDuringMemtableCompaction
	)

◆ TEST() [115/144]

leveldb::TEST	(	DBTest	,
		MinorCompactionsHappen
	)

◆ TEST() [116/144]

leveldb::TEST	(	DBTest	,
		RecoverWithLargeLog
	)

◆ TEST() [117/144]

leveldb::TEST	(	DBTest	,
		CompactionsGenerateMultipleFiles
	)

◆ TEST() [118/144]

leveldb::TEST	(	DBTest	,
		RepeatedWritesToSameKey
	)

◆ TEST() [119/144]

leveldb::TEST	(	DBTest	,
		SparseMerge
	)

◆ TEST() [120/144]

leveldb::TEST	(	DBTest	,
		ApproximateSizes
	)

◆ TEST() [121/144]

leveldb::TEST	(	DBTest	,
		ApproximateSizes_MixOfSmallAndLarge
	)

◆ TEST() [122/144]

leveldb::TEST	(	DBTest	,
		IteratorPinsRef
	)

◆ TEST() [123/144]

leveldb::TEST	(	DBTest	,
		Snapshot
	)

◆ TEST() [124/144]

leveldb::TEST	(	DBTest	,
		HiddenValuesAreRemoved
	)

◆ TEST() [125/144]

leveldb::TEST	(	DBTest	,
		DeletionMarkers1
	)

◆ TEST() [126/144]

leveldb::TEST	(	DBTest	,
		DeletionMarkers2
	)

◆ TEST() [127/144]

leveldb::TEST	(	DBTest	,
		OverlapInLevel0
	)

◆ TEST() [128/144]

leveldb::TEST	(	DBTest	,
		L0_CompactionBug_Issue44_a
	)

◆ TEST() [129/144]

leveldb::TEST	(	DBTest	,
		L0_CompactionBug_Issue44_b
	)

◆ TEST() [130/144]

leveldb::TEST	(	DBTest	,
		ComparatorCheck
	)

◆ TEST() [131/144]

leveldb::TEST	(	DBTest	,
		CustomComparator
	)

◆ TEST() [132/144]

leveldb::TEST	(	DBTest	,
		ManualCompaction
	)

◆ TEST() [133/144]

leveldb::TEST	(	DBTest	,
		DBOpen_Options
	)

◆ TEST() [134/144]

leveldb::TEST	(	DBTest	,
		Locking
	)

◆ TEST() [135/144]

leveldb::TEST	(	DBTest	,
		NoSpace
	)

◆ TEST() [136/144]

leveldb::TEST	(	DBTest	,
		NonWritableFileSystem
	)

◆ TEST() [137/144]

leveldb::TEST	(	DBTest	,
		WriteSyncError
	)

◆ TEST() [138/144]

leveldb::TEST	(	DBTest	,
		ManifestWriteError
	)

◆ TEST() [139/144]

leveldb::TEST	(	DBTest	,
		MissingSSTFile
	)

◆ TEST() [140/144]

leveldb::TEST	(	DBTest	,
		StillReadSST
	)

◆ TEST() [141/144]

leveldb::TEST	(	DBTest	,
		FilesDeletedAfterCompaction
	)

◆ TEST() [142/144]

leveldb::TEST	(	DBTest	,
		BloomFilter
	)

◆ TEST() [143/144]

leveldb::TEST	(	DBTest	,
		MultiThreaded
	)

◆ TEST() [144/144]

leveldb::TEST	(	DBTest	,
		Randomized
	)

◆ TestEncodeDecode()

static void leveldb::TestEncodeDecode ( const VersionEdit & edit )

static

◆ TestKey()

static void leveldb::TestKey	(	const std::string &	key,
		uint64_t	seq,
		ValueType	vt
	)

static

◆ ThreadBody()

static void leveldb::ThreadBody ( void * arg )

static

◆ TotalFileSize()

static int64_t leveldb::TotalFileSize ( const std::vector< FileMetaData * > & files )

static

◆ UnrefEntry()

static void leveldb::UnrefEntry	(	void *	arg1,
		void *	arg2
	)

static

◆ VarintLength()

int leveldb::VarintLength ( uint64_t v )

◆ WriteStringToFile()

Status leveldb::WriteStringToFile	(	Env *	env,
		const Slice &	data,
		const std::string &	fname
	)

◆ WriteStringToFileSync()

Status leveldb::WriteStringToFileSync	(	Env *	env,
		const Slice &	data,
		const std::string &	fname
	)

Variable Documentation

◆ bytewise

const Comparator* leveldb::bytewise

static

◆ default_env

Env* leveldb::default_env

static

◆ kBlockSize

const int leveldb::kBlockSize = 4096

static

◆ kBlockTrailerSize

const size_t leveldb::kBlockTrailerSize = 5

static

◆ kCount

const int leveldb::kCount = kTotalSize / kValueSize

static

◆ kDelayMicros [1/2]

const int leveldb::kDelayMicros = 100000

static

◆ kDelayMicros [2/2]

const int leveldb::kDelayMicros = 100000

static

◆ kFilterBase

const size_t leveldb::kFilterBase = 1 << kFilterBaseLg

static

◆ kFilterBaseLg

const size_t leveldb::kFilterBaseLg = 11

static

◆ kHeader

const size_t leveldb::kHeader = 12

static

◆ kMajorVersion

const int leveldb::kMajorVersion = 1

static

◆ kMaxNumValues

const int leveldb::kMaxNumValues = 2000

static

◆ kMaxSequenceNumber

const SequenceNumber leveldb::kMaxSequenceNumber

static

Initial value:

=

((0x1ull << 56) - 1)

◆ kMinorVersion

const int leveldb::kMinorVersion = 20

static

◆ kMMapLimit [1/2]

const int leveldb::kMMapLimit = 4

static

◆ kMMapLimit [2/2]

const int leveldb::kMMapLimit = 4

static

◆ kNumIterations

const size_t leveldb::kNumIterations = 3

static

◆ kNumNonTableCacheFiles

const int leveldb::kNumNonTableCacheFiles = 10

◆ kNumTestArgs

const int leveldb::kNumTestArgs = sizeof(kTestArgList) / sizeof(kTestArgList[0])

static

◆ kReadOnlyFileLimit [1/2]

const int leveldb::kReadOnlyFileLimit = 4

static

◆ kReadOnlyFileLimit [2/2]

const int leveldb::kReadOnlyFileLimit = 4

static

◆ kTableMagicNumber

const uint64_t leveldb::kTableMagicNumber = 0xdb4775248b80fb57ull

static

◆ kTestArgList

const TestArgs leveldb::kTestArgList[]

static

Initial value:

= {
  { TABLE_TEST, false, 16 },
  { TABLE_TEST, false, 1 },
  { TABLE_TEST, false, 1024 },
  { TABLE_TEST, true, 16 },
  { TABLE_TEST, true, 1 },
  { TABLE_TEST, true, 1024 },
  { BLOCK_TEST, false, 16 },
  { BLOCK_TEST, false, 1 },
  { BLOCK_TEST, false, 1024 },
  { BLOCK_TEST, true, 16 },
  { BLOCK_TEST, true, 1 },
  { BLOCK_TEST, true, 1024 },
  
  { MEMTABLE_TEST, false, 16 },
  { MEMTABLE_TEST, true, 16 },
  
  { DB_TEST, false, 16 },
  { DB_TEST, true, 16 },
}

◆ kTotalSize

const int leveldb::kTotalSize = 100 * 1024 * 1024

static

◆ kValueSize [1/3]

const int leveldb::kValueSize = 1000

static

◆ kValueSize [2/3]

const int leveldb::kValueSize = 1000

static

◆ kValueSize [3/3]

const int leveldb::kValueSize = 200 * 1024

static

◆ kValueTypeForSeek

const ValueType leveldb::kValueTypeForSeek = kTypeValue

static

◆ kVerbose

const int leveldb::kVerbose = 1

static

◆ once [1/2]

port::OnceType leveldb::once = LEVELDB_ONCE_INIT

static

◆ once [2/2]

pthread_once_t leveldb::once = PTHREAD_ONCE_INIT

static

◆ reverse_key_comparator

ReverseKeyComparator leveldb::reverse_key_comparator

static

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

◆ Key

◆ KVMap

◆ SequenceNumber

Enumeration Type Documentation

◆ CompressionType

◆ FileType

◆ Tag

◆ TestType

◆ ValueType

Function Documentation

◆ AfterFile()

◆ AppendEscapedStringTo()

◆ AppendInternalKey()

◆ AppendNumberTo()

◆ BeforeFile()

◆ Between() [1/2]

◆ Between() [2/2]

◆ BM_LogAndApply()

◆ BuildTable()

◆ BytewiseComparator()

◆ ClipToRange()

◆ CompareIterators()

◆ ConcurrentReader()

◆ ConsumeDecimalNumber()

◆ CurrentFileName()

◆ DecodeEntry()

◆ DecodeFixed32()

◆ DecodeFixed64()

◆ DecodeKey()

◆ DecodeValue()

◆ DeleteBlock()

◆ DeleteCachedBlock()

◆ DeleteEntry()

◆ DescriptorFileName()

◆ DestroyDB()

◆ DoWriteStringToFile()

◆ DumpFile()

◆ EncodeFixed32()

◆ EncodeFixed64()

◆ EncodeKey() [1/2]

◆ EncodeKey() [2/2]

◆ EncodeValue()

◆ EncodeVarint32()

◆ EncodeVarint64()

◆ EscapeString()

◆ ExpandedCompactionByteSizeLimit()

◆ ExtractUserKey()

◆ ExtractValueType()

◆ FindFile()

◆ GetFileIterator()

◆ GetInternalKey()

◆ GetLengthPrefixedSlice() [1/3]

◆ GetLengthPrefixedSlice() [2/3]

◆ GetLengthPrefixedSlice() [3/3]

◆ GetLevel()

◆ GetVarint32()

◆ GetVarint32Ptr()

◆ GetVarint32PtrFallback()

◆ GetVarint64()

◆ GetVarint64Ptr()

◆ Hash()

◆ IKey()

◆ Increment()

◆ InfoLogFileName()

◆ InitDefaultEnv()

◆ InitModule()

◆ InternalKeyEncodingLength()

◆ Key() [1/2]

◆ Key() [2/2]

◆ LockFileName()

◆ Log()

◆ LogFileName()

◆ MakeFileName()