leveldb的入门级使用

#include <cassert>
#include <leveldb/db.h>
#include <leveldb/status.h>

leveldb::DB *db;                              // 数据库操作句柄
leveldb::Options options;                     // 设置选项
options.create_if_missing = true;             // 不存在的情况下创建
leveldb::Status status = leveldb::Open(options, "/path/to/db", &db);    // Open操作
assert(status.ok());                          // 断言操作后的状态

// leveldb/src/include/options.h

struct Options {
  bool create_if_missing;        // 类似于 O_CREATE 选项 default: false
  bool error_if_exists;          // 与上面的选项同时设置会报错 default: false
  bool paranoid_checks;
  Env* env;                      // leveldb与操作系统底层的交互, default: Env::default()
  Logger* info_log;              // 设置日志级别
  size_t write_buffer_size;      // 设置写缓冲区大小, 可用来调优 defualt: 4096KB
  int max_open_files;            // 最大打开文件数, 可用来调优  default: 1000
  Cache* block_cache;            // 设置Cache, 可以明显提高性能 defualt: false
  size_t block_size;             // 设置block块大小 defualt: 4MB
  int block_restart_interval;
  CompressionType compression;   // 使用的压缩算法, 可以配合Google开源压缩算法使用
  const FilterPolicy* filter_policy;   // 设置过滤器, 如Bloom Filter, default: NULL
  Options();                      // 默认构造函数
};

// leveldb/src/include/status.h

class Status {
 public:
  C-tor ...
  
  Status getter ...
  
  // 判断状态的各类函数
  bool ok() const { return (state_ == NULL); }
  bool IsNotFound() const { return code() == kNotFound; }
  bool IsCorruption() const { return code() == kCorruption; }
  bool IsIOError() const { return code() == kIOError; }

  // if(!status.ok()), 可以输出错误, 类似于std::exception::what()
  std::string ToString() const;

 private:
  // 保存状态的是字符串, state_[0..3]为长度, state_[4]为Code, state_[5...]为message
  const char* state_;

  // 设置的状态位, 1, 2, 3, 4, 5
  enum Code {
    kOk = 0,
    kNotFound = 1,
    kCorruption = 2,
    kNotSupported = 3,
    kInvalidArgument = 4,
    kIOError = 5
  };

  // 获取Code
  Code code() const {
    return (state_ == NULL) ? kOk : static_cast<Code>(state_[4]);
  }

  ...
};

//interface

Status Put(const WriteOptions& options, const Slice& key, const Slice& value);
Status Get(cosnt ReadOptions& options, const Slice& key, std::string *value);
Status Delte(const WriteOptions& options, const Slice& key);

#include <leveldb/db.h>

... open a database

const slice/std::string key(...);
std::string value;
auto status = db->Put(leveldb::WriteOptions(), key, value);
if (status.ok()) status = db->Get(leveldb::ReadOptions(), key, &value);
if (status.ok()) status = db->Delete(leveldb::WriteOptions(), key);

#include <leveldb/db.h>
#include <leveldb/write_batch.h>
#include <leveldb/options.h>

open a database...

auto status = db->Put(leveldb::WriteOptions(), key, value);
if (status.ok()) {
    leveldb::WriteBatch batch;
    batch.Delete(key);
    batch.Put(leveldb::WriteOptions(), key_, value_);
    status = db->Write(leveldb::WriteOptions(), &batch);
}

// leveldb::Iterator

bool Valid() const;                   # 判断是否合法, 控制遍历条件
void SeekToFirst();                   # STL::Begin()
void SeekToLast()                     # STL::End()
void Seek(const Slice& target);       # 可以跳转到指定位置
void Next();                          # 后向移动, STL::Iterator++
void Prev();                          # 前向移动, STL::Iterator--
Slice key() const;                    # 返回节点Key
Slice value() const;                  # 返回节点Value
Status status() const;                # 返回节点Status

auto iter = db->NewIterator(leveldb::ReadOptions());                 // (1)
for (iter->SeekToFirst(); iter->Valid(); iter->Next())
    std::cout << iter->key().ToString() << " " << iter->value().ToString() << std::endl;

// [start, limit)
auto iter = db->NewIterator(leveldb::ReadOptions());                 // (2)
for (iter->Seek(key) && iter->key() < limit; 
     iter->Valid(); 
     iter->Next())
    ...

auto iter = db->NewIterator(leveldb::ReadOptions());                 // (3)
for (iter->SeekToLast(); iter->Valid(); iter->Prev())
    ...

leveldb::ReadOptions read_options;
read_options.snapshot = db->GetSnapshot();
...
...

db->ReleaseSnapshot(oread_options.snapshot);

class LEVELDB_EXPORT Slice {
 public:
  ........ // interface
 private:
  const char* data_;
  size_t size_;
};

{
    Slice slice;
    if (...) {
        slice = std::string("key");        // WARRRRRRRR !
	}
    db->Get(leveldb::ReadOptions(), slice, &val);
}

// Create a slice that refers to the contents of "s"
  Slice(const std::string& s) : data_(s.data()), size_(s.size()) { }

#include <leveldb/comparator.h>

class OtherComparator : public leveldb::Comparator {

# 最核心的比较器接口
virtual int Compare(const Slice& a, const Slice& b) const = 0;

# 下面三个用来实现向后兼容性
virtual const char* Name() const = 0;
virtual void FindShortestSeparator(
      std::string* start,
      const Slice& limit) const = 0;
virtual void FindShortSuccessor(std::string* key) const = 0;
}

#include <leveldb/db.h>

leveldb::DB *db;
leveldb::Options options;
OthreComparator cmp;
options.comparator = &cmp;

leveldb::Open(options, "path/to/db", &db);

// 实现以下接口即可

class OthreFileterPolicy : public leveldb::FiuleterPolicy {
 public:
  virtual const char* Name() const = 0;

  virtual void CreateFilter(const Slice* keys, int n, std::string* dst)
      const = 0;

  virtual bool KeyMayMatch(const Slice& key, const Slice& filter) const = 0;
};

}

leveldb::DB *db;
leveldb::Options options;
OthreFileterPolicy filter;
options.filter_policy = &filter;

leveldb::Open(options, "path/to/db", &db);

class OtherEnv : public leveldb::Env {
    .. implementation of the Env interface ...
  };

OtherEnv env;
leveldb::Options options;
options.env = &env;
Status s = leveldb::DB::Open(options, ...);

leveldb::Options options;

options.block_size = xxx;                             # 设置block size
options.compression = leveldb::KNocompression;        # 设置压缩方式
options.cache = leveldb::NewLRUCache(100 * 1048576);  # 设置缓存
options.filter_policy = xxxxxx;                       # 设置过滤器

leveldb::WriteOptions options;
options.sync = true;

db->Put(options, ...);