一個簡單的leveldb使用示例如下：

#include <assert.h>
#include <iostream>
#include "leveldb/db.h"
#include "leveldb/env.h"
using namespace std;

#include <assert.h>
#include <iostream>
#include "leveldb/db.h"
#include "leveldb/env.h"

using namespace std;

int main()
{
leveldb::DB *db;
leveldb::Options ops;
ops.create_if_missing=true
 
;
std::string dbpath="testdb";
leveldb::Status status=leveldb::DB::Open(ops,dbpath,&db);
assert(status.ok());
string key="lili";
string value="hihi";

string res;
status=db->Put(leveldb::WriteOptions(),key,value);//將Key-Value插入到leveldb中
status=db->Get(leveldb::ReadOptions(),key,&res);//根據Key值在leveldb中查詢其對應的Value，返回值存放在res中
 


cout<<res<<endl;
delete db;
return 0;
}

Put操作

1、根據leveldb的原始碼可知，leveldb::DB是一個抽象基類，其中定義了一些純虛擬函式，包括Put和Get等，使其只能作為父類被繼承，而不能被例項化。leveldb::DBImpl繼承自該基類，因此在呼叫db->Put()時，首先呼叫的是leveldb::DBImpl->Put()方法:

Status DBImpl::Put(const WriteOptions& o, const Slice& key, const Slice& val) {
  return
 
 DB::Put(o, key, val);
}

在該方法中，只是簡單的呼叫父類leveldb::DB實現的Put()方法，leveldb::DBImpl只是提供一個介面。

2、以前以為純虛擬函式是隻能定義不能實現的，通過leveldb才發現原來純虛擬函式也是可以實現的，然後被顯式呼叫。leveldb::DB中的Put方法如下：

Status DB::Put(const WriteOptions& opt, const Slice& key, const Slice& value) {
  WriteBatch batch;
  batch.Put(key, value);//將key,value組織成一條記錄存放在batch中
  return Write(opt, &batch);//呼叫Write方法寫入記錄
}

一條記錄包含如下內容：
Type、Key、Value
當要插入記錄時，Type為kTypeValue，當要刪除記錄時，Type為kTypeDeletion，同時中每一個batch都有一個對當前批處理記錄資訊的統計（sequence（8位元組）和count（4位元組），共12位元組）
由此可見，當我們要刪除一個數據時，並不是直接從記憶體中刪除，而是插入一條帶有刪除標誌的記錄

在本例中要插入資料：key=”lili”; value=”hihi”;
由之前對WriterBatch的分析可知，得到的batch為：
01 00 00 00 00 00 00 00 01 00 00 00 （前8位元組表示是第一個batch，後4位元組表示此batch中只有一條記錄）
01(kTypeValue) 04(Key.size) 6C 69 6C 69(lili) 04(value.size) 68 69 68 69(hihi)
共12+1+1+4+1+4=23位元組=0x17

3、然後呼叫leveldb::DBImpl->Write()寫入記錄：

Status DBImpl::Write(const WriteOptions& options, WriteBatch* my_batch) {
  Writer w(&mutex_);
  w.batch = my_batch;
  w.sync = options.sync;//default is false
  w.done = false;

  MutexLock l(&mutex_);
  writers_.push_back(&w);//將writer加入任務佇列deque
  while (!w.done && &w != writers_.front()) {//未執行，且不在任務佇列首部，則等待
    w.cv.Wait();
  }
  if (w.done) {//已執行完畢，返回status
    return w.status;
  }

  //確保有Memtable和log檔案可以用於資料的寫入，對已寫滿的Memtable後臺排程Compaction
  Status status = MakeRoomForWrite(my_batch == NULL);
  uint64_t last_sequence = versions_->LastSequence();
  Writer* last_writer = &w;
  if (status.ok() && my_batch != NULL) {// 當batch為空時，是準備執行compactions操作，否則插入記錄
    WriteBatch* updates = BuildBatchGroup(&last_writer);//將任務佇列中所有的非同步任務組織在一起形成一個WriteBatch，一起批量寫入，可以極大的提升寫的效率
    WriteBatchInternal::SetSequence(updates, last_sequence + 1);
    last_sequence += WriteBatchInternal::Count(updates);

    {
      mutex_.Unlock();
      status = log_->AddRecord(WriteBatchInternal::Contents(updates));//呼叫fwrite將記錄寫入log檔案中
      bool sync_error = false;
      if (status.ok() && options.sync) {
        status = logfile_->Sync();//若設定了同步，則每次寫成功後都同步一次
      }
      if (status.ok()) {
        status = WriteBatchInternal::InsertInto(updates, mem_);//將updates中的記錄插入到mem_中
      }
      mutex_.Lock();
    }
    if (updates == tmp_batch_) tmp_batch_->Clear();
    versions_->SetLastSequence(last_sequence);
  }

  while (true) {//等待佇列中的其它任務
    Writer* ready = writers_.front();
    writers_.pop_front();
    if (ready != &w) {
      ready->status = status;
      ready->done = true;
      ready->cv.Signal();
    }
    if (ready == last_writer) break;
  }

  // Notify new head of write queue
  if (!writers_.empty()) {
    writers_.front()->cv.Signal();
  }
  return status;
}

通過呼叫log_->AddRecord()將記錄寫入到log中，由之前對log檔案寫操作的分析 可知，log檔案每次寫入一個batch的時候都會在前面為其加上7位元組的首部（CRC（4位元組）、記錄長度（2位元組）、type（1位元組）），其中CRC與type有關。
對於本例，length=23=0x17位元組
記錄為第一個，且不會佔滿當前block，因此type為 kFullType=0x01

最終在testdb目錄下的.log檔案中可看到如下結果：
00000000h: 66 5F 61 EE 17 00 01 01 00 00 00 00 00 00 00 01 ; f_a?………..
00000010h: 00 00 00 01 04 6C 69 6C 69 04 68 69 68 69 ; …..lili.hihi

向log檔案中寫入成功後，會呼叫WriteBatchInternal::InsertInto()將記錄插入到Memtable中，記錄在Memtable中是按照user_key升序，sequence降序排列的，這樣所有user _key相同的記錄都是聚集在一起的，且其中第一個就是最新的記錄，在後面的合併操作中，我們只需要處理相同user _key的第一條記錄即可，後面的都可以丟棄。
寫操作可能會導致Memtable寫滿，此時就需要將其轉化為immutable memtable，並在後臺呼叫合併操作將其轉化為SSTable。這是在MakeRoomForWrite()中完成的。

Get操作

db->Get()會呼叫DBImpl::Get(const ReadOptions& options,const Slice& key,std::string* value)，查詢key對應的值存放到value中。

Status DBImpl::Get(const ReadOptions& options,
                   const Slice& key,
                   std::string* value) {
  Status s;
  MutexLock l(&mutex_);
  MemTable* mem = mem_;
  MemTable* imm = imm_;
  Version* current = versions_->current();
  mem->Ref();
  if (imm != NULL) imm->Ref();
  current->Ref();

  bool have_stat_update = false;
  Version::GetStats stats;

  // Unlock while reading from files and memtables
  {//主要的查詢操作，，
    mutex_.Unlock();
    // First look in the memtable, then in the immutable memtable (if any).
    LookupKey lkey(key, snapshot);
    if (mem->Get(lkey, value, &s)) {//首先在memtable中查詢
      // Done
    } else if (imm != NULL && imm->Get(lkey, value, &s)) {//若沒找到則繼續在immutable memtable中查詢
      // Done
    } else {//若還沒找到，則繼續在sstable中查詢
      s = current->Get(options, lkey, value, &stats);
      have_stat_update = true;
    }
    mutex_.Lock();
  }

  if (have_stat_update && current->UpdateStats(stats)) {
    MaybeScheduleCompaction();//可能進行campact操作
  }
  mem->Unref();
  if (imm != NULL) imm->Unref();
  current->Unref();
  return s;
}

由上可知，leveldb是按照Memtable、immutable memtable，SSTable的優先順序來進行查詢的。其中每個SSTable檔案都是有查詢次數限制的，在FileMetaData（記錄每個.sst檔案資訊的資料結構）中被初始化的。因此在SSTable中查詢時，也可能會觸發合併操作。
在查詢時用到了version，leveldb 使用 version 來儲存資料庫的狀態，Version 儲存了所有level的所有的SSTable檔案資訊，通過version->Current()可用來獲取”current” version（當前版本）。
在SSTable中查詢時，首先是從低到高遍歷當前Version中所有level中的所有檔案，逐個找出Key值範圍覆蓋了目標Key值的檔案，然後依次在這些檔案中進行查詢。
每一個數據庫中都有一個快取變數table_cache，用於快取最近使用的.sst檔案資訊，由於記憶體訪問速度比磁碟訪問速度快得多，這樣可以極大的提高查詢的效率。因此在查詢.sst檔案時，若.sst檔案不在快取中，則將其加入快取。