src/leveldbwrapper.h

   1 // Copyright (c) 2012-2014 The Bitcoin Core developers
   2 // Distributed under the MIT software license, see the accompanying
   3 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
   4
   5 #ifndef BITCOIN_LEVELDBWRAPPER_H
   6 #define BITCOIN_LEVELDBWRAPPER_H
   7
   8 #include "clientversion.h"
   9 #include "serialize.h"
  10 #include "streams.h"
  11 #include "util.h"
  12 #include "version.h"
  13
  14 #include <boost/filesystem/path.hpp>
  15
  16 #include <leveldb/db.h>
  17 #include <leveldb/write_batch.h>
  18
  19 class leveldb_error : public std::runtime_error
  20 {
  21 public:
  22     leveldb_error(const std::string& msg) : std::runtime_error(msg) {}
  23 };
  24
  25 void HandleError(const leveldb::Status& status) throw(leveldb_error);
  26
  27 /** Batch of changes queued to be written to a CLevelDBWrapper */
  28 class CLevelDBBatch
  29 {
  30     friend class CLevelDBWrapper;
  31
  32 private:
  33     leveldb::WriteBatch batch;
  34
  35 public:
  36     template <typename K, typename V>
  37     void Write(const K& key, const V& value)
  38     {
  39         CDataStream ssKey(SER_DISK, CLIENT_VERSION);
  40         ssKey.reserve(ssKey.GetSerializeSize(key));
  41         ssKey << key;
  42         leveldb::Slice slKey(&ssKey[0], ssKey.size());
  43
  44         CDataStream ssValue(SER_DISK, CLIENT_VERSION);
  45         ssValue.reserve(ssValue.GetSerializeSize(value));
  46         ssValue << value;
  47         leveldb::Slice slValue(&ssValue[0], ssValue.size());
  48
  49         batch.Put(slKey, slValue);
  50     }
  51
  52     template <typename K>
  53     void Erase(const K& key)
  54     {
  55         CDataStream ssKey(SER_DISK, CLIENT_VERSION);
  56         ssKey.reserve(ssKey.GetSerializeSize(key));
  57         ssKey << key;
  58         leveldb::Slice slKey(&ssKey[0], ssKey.size());
  59
  60         batch.Delete(slKey);
  61     }
  62 };
  63
  64 class CLevelDBWrapper
  65 {
  66 private:
  67     //! custom environment this database is using (may be NULL in case of default environment)
  68     leveldb::Env* penv;
  69
  70     //! database options used
  71     leveldb::Options options;
  72
  73     //! options used when reading from the database
  74     leveldb::ReadOptions readoptions;
  75
  76     //! options used when iterating over values of the database
  77     leveldb::ReadOptions iteroptions;
  78
  79     //! options used when writing to the database
  80     leveldb::WriteOptions writeoptions;
  81
  82     //! options used when sync writing to the database
  83     leveldb::WriteOptions syncoptions;
  84
  85     //! the database itself
  86     leveldb::DB* pdb;
  87
  88 public:
  89     CLevelDBWrapper(const boost::filesystem::path& path, size_t nCacheSize, bool fMemory = false, bool fWipe = false);
  90     ~CLevelDBWrapper();
  91
  92     template <typename K, typename V>
  93     bool Read(const K& key, V& value) const throw(leveldb_error)
  94     {
  95         CDataStream ssKey(SER_DISK, CLIENT_VERSION);
  96         ssKey.reserve(ssKey.GetSerializeSize(key));
  97         ssKey << key;
  98         leveldb::Slice slKey(&ssKey[0], ssKey.size());
  99
 100         std::string strValue;
 101         leveldb::Status status = pdb->Get(readoptions, slKey, &strValue);
 102         if (!status.ok()) {
 103             if (status.IsNotFound())
 104                 return false;
 105             LogPrintf("LevelDB read failure: %s\n", status.ToString());
 106             HandleError(status);
 107         }
 108         try {
 109             CDataStream ssValue(strValue.data(), strValue.data() + strValue.size(), SER_DISK, CLIENT_VERSION);
 110             ssValue >> value;
 111         } catch (const std::exception&) {
 112             return false;
 113         }
 114         return true;
 115     }
 116
 117     template <typename K, typename V>
 118     bool Write(const K& key, const V& value, bool fSync = false) throw(leveldb_error)
 119     {
 120         CLevelDBBatch batch;
 121         batch.Write(key, value);
 122         return WriteBatch(batch, fSync);
 123     }
 124
 125     template <typename K>
 126     bool Exists(const K& key) const throw(leveldb_error)
 127     {
 128         CDataStream ssKey(SER_DISK, CLIENT_VERSION);
 129         ssKey.reserve(ssKey.GetSerializeSize(key));
 130         ssKey << key;
 131         leveldb::Slice slKey(&ssKey[0], ssKey.size());
 132
 133         std::string strValue;
 134         leveldb::Status status = pdb->Get(readoptions, slKey, &strValue);
 135         if (!status.ok()) {
 136             if (status.IsNotFound())
 137                 return false;
 138             LogPrintf("LevelDB read failure: %s\n", status.ToString());
 139             HandleError(status);
 140         }
 141         return true;
 142     }
 143
 144     template <typename K>
 145     bool Erase(const K& key, bool fSync = false) throw(leveldb_error)
 146     {
 147         CLevelDBBatch batch;
 148         batch.Erase(key);
 149         return WriteBatch(batch, fSync);
 150     }
 151
 152     bool WriteBatch(CLevelDBBatch& batch, bool fSync = false) throw(leveldb_error);
 153
 154     // not available for LevelDB; provide for compatibility with BDB
 155     bool Flush()
 156     {
 157         return true;
 158     }
 159
 160     bool Sync() throw(leveldb_error)
 161     {
 162         CLevelDBBatch batch;
 163         return WriteBatch(batch, true);
 164     }
 165
 166     // not exactly clean encapsulation, but it's easiest for now
 167     leveldb::Iterator* NewIterator()
 168     {
 169         return pdb->NewIterator(iteroptions);
 170     }
 171 };
 172
 173 #endif // BITCOIN_LEVELDBWRAPPER_H