cd ~/github
git clone https://github.com/google/leveldb.git
cd leveldb

vim Makefile

# OPT ?= -O2 -DNDEBUG
OPT ?= -ggdb3

ar: creating libleveldb.a

touch test.cpp

#include <assert.h>
#include <string.h>
#include <leveldb/db.h>
#include <iostream>


int main(){
	leveldb::DB* db;
	leveldb::Options options;
	options.create_if_missing = true;
	leveldb::Status status = leveldb::DB::Open(options,"/tmp/testdb", &db);
	assert(status.ok());

	//write key1,value1
	std::string key="key";
	std::string value = "value";

	status = db->Put(leveldb::WriteOptions(), key,value);
	assert(status.ok());

    for ( int i = 0; i < 1000000; i++) {
        char str[100];
        snprintf(str, sizeof(str), "%d", i);
        status = db->Put(leveldb::WriteOptions(), str, str);
    }

	status = db->Get(leveldb::ReadOptions(), key, &value);
	assert(status.ok());
	std::cout<<value<<std::endl;
	std::string key2 = "key2";

	//move the value under key to key2
	status = db->Put(leveldb::WriteOptions(),key2,value);
	assert(status.ok());
	status = db->Delete(leveldb::WriteOptions(), key);

	assert(status.ok());

	status = db->Get(leveldb::ReadOptions(),key2, &value);

	assert(status.ok());
	std::cout<<key2<<"==="<<value<<std::endl;

	status = db->Get(leveldb::ReadOptions(),key, &value);

	if(!status.ok()) std::cerr<<key<<"  "<<status.ToString()<<std::endl;
	else std::cout<<key<<"==="<<value<<std::endl;

	delete db;
	return 0;
}

g++ test.cpp -o test -L. -I./include -lpthread -lleveldb

gdb test
break main
break leveldb::DB::open
r

$ tree -I "*test*"
.
├── AUTHORS
├── build_detect_platform
├── db #具体逻辑
│   ├── builder.cc  # 定义了BuildTable函数
│   ├── builder.h
│   ├── c.cc        # c封装，暂时不用看
│   ├── db_bench.cc
│   ├── dbformat.cc # 搞懂几个key的关系即可，internal，lookupkey
│   ├── dbformat.h
│   ├── db_impl.cc # 具体实现,DBImpl::Write是重中之重
│   ├── db_impl.h
│   ├── db_iter.cc
│   ├── db_iter.h
│   ├── filename.cc   # 管理db目录下的个各个文件
│   ├── filename.h    # 管理db目录下的个各个文件
│   ├── log_format.h  # 物理日志格式定义
│   ├── log_reader.cc # 读物理日志,ReadRecord
│   ├── log_reader.h
│   ├── log_writer.cc # 日志封装成相应的格式，并写入物理日志
│   ├── log_writer.h
│   ├── memtable.cc   # memtable定义，对记录进行格式化，并调用skiplist的相应接口
│   ├── memtable.h    #
│   ├── repair.cc     # 啥？
│   ├── skiplist.h    # skiplist的定义
│   ├── snapshot.h    # 成员变量只有SequenceNumber的双链表<http://www.blogjava.net/sandy/archive/2012/03/13/leveldb5.html>
│   ├── table_cache.cc # 缓存sst文件，保存sst文件与Table的对应关系，
│   ├── table_cache.h  # 要想全部搞懂Table，还需要弄清楚format.cc
│   ├── version_edit.cc #啥?
│   ├── version_edit.h
│   ├── version_set.cc
│   ├── version_set.h
│   ├── write_batch.cc  # 批量写操作的实现，WriteBatch::Iterate
│   └── write_batch_internal.h # 批量操作辅助文件
├── doc #帮助文档
│   ├── bench
│   │   ├── db_bench_sqlite3.cc
│   │   └── db_bench_tree_db.cc
│   ├── benchmark.html
│   ├── doc.css
│   ├── impl.html
│   ├── index.html
│   ├── log_format.txt
│   └── table_format.txt
├── helpers
│   └── memenv
│   ├── memenv.cc
│   └── memenv.h
├── include        # 接口
│   └── leveldb
│   ├── cache.h
│   ├── c.h
│   ├── comparator.h
│   ├── db.h
│   ├── env.h
│   ├── filter_policy.h
│   ├── iterator.h
│   ├── options.h
│   ├── slice.h
│   ├── status.h
│   ├── table_builder.h
│   ├── table.h
│   └── write_batch.h
├── libleveldb.so.1.4
├── LICENSE
├── Makefile
├── NEWS
├── port
│   ├── atomic_pointer.h  # 无锁编程
│   ├── port_android.cc
│   ├── port_android.h
│   ├── port_example.h
│   ├── port.h
│   ├── port_posix.cc
│   ├── port_posix.h
│   ├── README
│   └── win
│   └── stdint.h
├── README
├── table
│   ├── block_builder.cc # 构造block，准备写入
│   ├── block_builder.h  # 构造block，准备写入
│   ├── block.cc         # 通过ReadBlock读取，通过迭代器读取各个record
│   ├── block.h          # 读取block。定义了block，和相应的迭代器
│   ├── filter_block.cc  # 与block类似，用以处理filter_block
│   ├── filter_block.h   # 与block类似，用以处理filter_block
│   ├── format.cc        # 定义了ReadBlock函数[重点]
│   ├── format.h         # 定义了BlockContent，BlockHandle，Footer
│   ├── iterator.cc      # 迭代器？
│   ├── iterator_wrapper.h # 迭代器？
│   ├── merger.cc        # 定义了MergingIterator迭代器
│   ├── merger.h
│   ├── table_builder.cc # 构造Table，Add()、Flush()、WriteBlock
│   ├── table.cc         # 定义了操作table的方法，InternalGet
│   ├── two_level_iterator.cc # 定义了TwoLevelIterator迭代器
│   └── two_level_iterator.h
├── TODO
└── util
	├── arena.cc       # 内存分配器
	├── arena.h        # 内存分配器
	├── bloom.cc       # 布隆过滤器
	├── cache.cc       # Cache
	├── coding.cc
	├── coding.h       # 编码
	├── comparator.cc  # 比较函数
	├── crc32c.cc      # crc32校验
	├── crc32c.h       # crc32校验
	├── env.cc         #日志相关
	├── env_posix.cc   # 文件操作封装和线程封装
	├── filter_policy.cc
	├── hash.cc        # hash函数
	├── hash.h         # hash函数
	├── histogram.cc   # 测试文件
	├── histogram.h    # 测试文件
	├── logging.cc     # 日志
	├── logging.h      # 日志头文件
	├── mutexlock.h    # mutex
	├── options.cc     # option
	├── posix_logger.h # 日志文件
	├── random.h       # 随机数生成器
	└── status.cc      # 错误管理，Status

	11 directories, 109 files

// BlockHandle is a pointer to the extent of a file that stores a data
// block or a meta block.
class BlockHandle {
 public:
  BlockHandle();

  // The offset of the block in the file.
  uint64_t offset() const { return offset_; }
  void set_offset(uint64_t offset) { offset_ = offset; }

  // The size of the stored block
  uint64_t size() const { return size_; }
  void set_size(uint64_t size) { size_ = size; }

  void EncodeTo(std::string* dst) const;
  Status DecodeFrom(Slice* input);

  // Maximum encoding length of a BlockHandle
  enum { kMaxEncodedLength = 10 + 10 };

 private:
  uint64_t offset_;
  uint64_t size_;
};

struct BlockContents {
  Slice data;           // Actual contents of data
  bool cachable;        // True iff data can be cached
  bool heap_allocated;  // True iff caller should delete[] data.data()
};

enum FileType {
  kLogFile,
  kDBLockFile,
  kTableFile,
  kDescriptorFile,
  kCurrentFile,
  kTempFile,
  kInfoLogFile  // Either the current one, or an old one
};

#-1 WriteLevel0Table
#0  leveldb::SkipList<char const*, leveldb::MemTable::KeyComparator>::Insert (this=0x8096ddc,
    key=@0xbffff364: 0x8096e2c "\vkey\001", <incomplete sequence \374>) at ./db/skiplist.h:338
#1  0x0805b61c in leveldb::MemTable::Add (this=0x8096db8, s=64560, type=leveldb::kTypeValue, key=..., value=...) at db/memtable.cc:105
#2  0x08067ede in leveldb::(anonymous namespace)::MemTableInserter::Put (this=0xbffff470, key=..., value=...) at db/write_batch.cc:118
#3  0x08067be6 in leveldb::WriteBatch::Iterate (this=0xbffff55c, handler=0xbffff470) at db/write_batch.cc:59
#4  0x08068012 in leveldb::WriteBatchInternal::InsertInto (b=0xbffff55c, memtable=0x8096db8) at db/write_batch.cc:133
#5  0x0804f886 in leveldb::DBImpl::Write (this=0x80962f0, options=..., my_batch=0xbffff55c) at db/db_impl.cc:1145
#6  0x08050806 in leveldb::DB::Put (this=0x80962f0, opt=..., key=..., value=...) at db/db_impl.cc:1369
#7  0x0804f56d in leveldb::DBImpl::Put (this=0x80962f0, o=..., key=..., val=...) at db/db_impl.cc:1103
#8  0x08049f66 in main () at test.cpp:22

#0  leveldb::SkipList<char const*, leveldb::MemTable::KeyComparator>::Iterator::Seek (this=0xbffff49c,
   target=@0xbffff4cc: 0xbffff564 "\vkey\001", <incomplete sequence \374>) at ./db/skiplist.h:223
#1  0x0805b3da in leveldb::MemTable::Get (this=0x8095db8, key=..., value=0xbffff6c0, s=0xbffff6c8) at db/memtable.cc:111
#2  0x0804ef5c in leveldb::DBImpl::Get (this=0x80952f0, options=..., key=..., value=0xbffff6c0) at db/db_impl.cc:1061
#3  0x08049fbd in main () at test.cpp:40

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

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

| Size (int32变长)| User key (string) | sequence number (7 bytes) | value type (1 byte) |

struct StartThreadState {
  void (*user_function)(void*);
  void* arg;
};
}
static void* StartThreadWrapper(void* arg) {
  StartThreadState* state = reinterpret_cast<StartThreadState*>(arg);
  state->user_function(state->arg);
  delete state;
  return NULL;
}

void PosixEnv::StartThread(void (*function)(void* arg), void* arg) {
  pthread_t t;
  StartThreadState* state = new StartThreadState;
  state->user_function = function;
  state->arg = arg;
  PthreadCall("start thread",
              pthread_create(&t, NULL,  &StartThreadWrapper, state));
}