database/leveldb/go_level_db.go

   1 package leveldb
   2
   3 import (
   4         "fmt"
   5         "path"
   6
   7         "github.com/syndtr/goleveldb/leveldb"
   8         "github.com/syndtr/goleveldb/leveldb/errors"
   9         "github.com/syndtr/goleveldb/leveldb/iterator"
  10         "github.com/syndtr/goleveldb/leveldb/opt"
  11         "github.com/syndtr/goleveldb/leveldb/util"
  12         . "github.com/tendermint/tmlibs/common"
  13
  14         "github.com/vapor/database/db"
  15 )
  16
  17 func init() {
  18         dbCreator := func(name string, dir string) (db.DB, error) {
  19                 return NewGoLevelDB(name, dir)
  20         }
  21         db.RegisterDBCreator(db.LevelDBBackendStr, dbCreator, false)
  22         db.RegisterDBCreator(db.GoLevelDBBackendStr, dbCreator, false)
  23 }
  24
  25 type GoLevelDB struct {
  26         db *leveldb.DB
  27 }
  28
  29 func NewGoLevelDB(name string, dir string) (*GoLevelDB, error) {
  30         dbPath := path.Join(dir, name+".db")
  31         db, err := leveldb.OpenFile(dbPath, nil)
  32         if err != nil {
  33                 return nil, err
  34         }
  35         database := &GoLevelDB{db: db}
  36         return database, nil
  37 }
  38
  39 func (db *GoLevelDB) Get(key []byte) []byte {
  40         res, err := db.db.Get(key, nil)
  41         if err != nil {
  42                 if err == errors.ErrNotFound {
  43                         return nil
  44                 } else {
  45                         PanicCrisis(err)
  46                 }
  47         }
  48         return res
  49 }
  50
  51 func (db *GoLevelDB) Set(key []byte, value []byte) {
  52         err := db.db.Put(key, value, nil)
  53         if err != nil {
  54                 PanicCrisis(err)
  55         }
  56 }
  57
  58 func (db *GoLevelDB) SetSync(key []byte, value []byte) {
  59         err := db.db.Put(key, value, &opt.WriteOptions{Sync: true})
  60         if err != nil {
  61                 PanicCrisis(err)
  62         }
  63 }
  64
  65 func (db *GoLevelDB) Delete(key []byte) {
  66         err := db.db.Delete(key, nil)
  67         if err != nil {
  68                 PanicCrisis(err)
  69         }
  70 }
  71
  72 func (db *GoLevelDB) DeleteSync(key []byte) {
  73         err := db.db.Delete(key, &opt.WriteOptions{Sync: true})
  74         if err != nil {
  75                 PanicCrisis(err)
  76         }
  77 }
  78
  79 func (db *GoLevelDB) DB() *leveldb.DB {
  80         return db.db
  81 }
  82
  83 func (db *GoLevelDB) Close() {
  84         db.db.Close()
  85 }
  86
  87 func (db *GoLevelDB) Print() {
  88         str, _ := db.db.GetProperty("leveldb.stats")
  89         fmt.Printf("%v\n", str)
  90
  91         iter := db.db.NewIterator(nil, nil)
  92         for iter.Next() {
  93                 key := iter.Key()
  94                 value := iter.Value()
  95                 fmt.Printf("[%X]:\t[%X]\n", key, value)
  96         }
  97 }
  98
  99 func (db *GoLevelDB) Stats() map[string]string {
 100         keys := []string{
 101                 "leveldb.num-files-at-level{n}",
 102                 "leveldb.stats",
 103                 "leveldb.sstables",
 104                 "leveldb.blockpool",
 105                 "leveldb.cachedblock",
 106                 "leveldb.openedtables",
 107                 "leveldb.alivesnaps",
 108                 "leveldb.aliveiters",
 109         }
 110
 111         stats := make(map[string]string)
 112         for _, key := range keys {
 113                 str, err := db.db.GetProperty(key)
 114                 if err == nil {
 115                         stats[key] = str
 116                 }
 117         }
 118         return stats
 119 }
 120
 121 type goLevelDBIterator struct {
 122         source iterator.Iterator
 123 }
 124
 125 // Key returns a copy of the current key.
 126 func (it *goLevelDBIterator) Key() []byte {
 127         key := it.source.Key()
 128         k := make([]byte, len(key))
 129         copy(k, key)
 130
 131         return k
 132 }
 133
 134 // Value returns a copy of the current value.
 135 func (it *goLevelDBIterator) Value() []byte {
 136         val := it.source.Value()
 137         v := make([]byte, len(val))
 138         copy(v, val)
 139
 140         return v
 141 }
 142
 143 func (it *goLevelDBIterator) Seek(point []byte) bool {
 144         return it.source.Seek(point)
 145 }
 146
 147 func (it *goLevelDBIterator) Error() error {
 148         return it.source.Error()
 149 }
 150
 151 func (it *goLevelDBIterator) Next() bool {
 152         return it.source.Next()
 153 }
 154
 155 func (it *goLevelDBIterator) Release() {
 156         it.source.Release()
 157 }
 158
 159 func (db *GoLevelDB) Iterator() db.Iterator {
 160         return &goLevelDBIterator{db.db.NewIterator(nil, nil)}
 161 }
 162
 163 func (db *GoLevelDB) IteratorPrefix(prefix []byte) db.Iterator {
 164         return &goLevelDBIterator{db.db.NewIterator(util.BytesPrefix(prefix), nil)}
 165 }
 166
 167 func (db *GoLevelDB) NewBatch() db.Batch {
 168         batch := new(leveldb.Batch)
 169         return &goLevelDBBatch{db, batch}
 170 }
 171
 172 //--------------------------------------------------------------------------------
 173
 174 type goLevelDBBatch struct {
 175         db    *GoLevelDB
 176         batch *leveldb.Batch
 177 }
 178
 179 func (mBatch *goLevelDBBatch) Set(key, value []byte) {
 180         mBatch.batch.Put(key, value)
 181 }
 182
 183 func (mBatch *goLevelDBBatch) Delete(key []byte) {
 184         mBatch.batch.Delete(key)
 185 }
 186
 187 func (mBatch *goLevelDBBatch) Write() {
 188         err := mBatch.db.db.Write(mBatch.batch, nil)
 189         if err != nil {
 190                 PanicCrisis(err)
 191         }
 192 }