From 9f81134388b0ddceeb0384f57c4f210018f27297 Mon Sep 17 00:00:00 2001 From: Jae Kwon Date: Tue, 29 Nov 2016 16:06:36 -0800 Subject: [PATCH 1/4] Add support for levigo bindings --- db.go | 14 ++++++ level_db.go | 27 ++++++++++ level_db2.go | 124 ++++++++++++++++++++++++++++++++++++++++++++++ level_db2_test.go | 84 +++++++++++++++++++++++++++++++ mem_db.go | 64 +++++++++++++++++++++++- 5 files changed, 312 insertions(+), 1 deletion(-) create mode 100644 level_db2.go create mode 100644 level_db2_test.go diff --git a/db.go b/db.go index 6bb1efae7..ab38501e2 100644 --- a/db.go +++ b/db.go @@ -13,16 +13,24 @@ type DB interface { Delete([]byte) DeleteSync([]byte) Close() + NewBatch() Batch // For debugging Print() } +type Batch interface { + Set(key, value []byte) + Delete(key []byte) + Write() +} + //----------------------------------------------------------------------------- // Database types const DBBackendMemDB = "memdb" const DBBackendLevelDB = "leveldb" +const DBBackendLevelDB2 = "leveldb2" func NewDB(name string, backend string, dir string) DB { switch backend { @@ -35,6 +43,12 @@ func NewDB(name string, backend string, dir string) DB { PanicCrisis(err) } return db + case DBBackendLevelDB2: + db, err := NewLevelDB2(path.Join(dir, name+".db")) + if err != nil { + PanicCrisis(err) + } + return db default: PanicSanity(Fmt("Unknown DB backend: %v", backend)) } diff --git a/level_db.go b/level_db.go index dee57a321..360362285 100644 --- a/level_db.go +++ b/level_db.go @@ -81,3 +81,30 @@ func (db *LevelDB) Print() { fmt.Printf("[%X]:\t[%X]\n", key, value) } } + +func (db *LevelDB) NewBatch() Batch { + batch := new(leveldb.Batch) + return &levelDBBatch{db, batch} +} + +//-------------------------------------------------------------------------------- + +type levelDBBatch struct { + db *LevelDB + batch *leveldb.Batch +} + +func (mBatch *levelDBBatch) Set(key, value []byte) { + mBatch.batch.Put(key, value) +} + +func (mBatch *levelDBBatch) Delete(key []byte) { + mBatch.batch.Delete(key) +} + +func (mBatch *levelDBBatch) Write() { + err := mBatch.db.db.Write(mBatch.batch, nil) + if err != nil { + PanicCrisis(err) + } +} diff --git a/level_db2.go b/level_db2.go new file mode 100644 index 000000000..e3049aae3 --- /dev/null +++ b/level_db2.go @@ -0,0 +1,124 @@ +package db + +import ( + "fmt" + "path" + + "github.com/jmhodges/levigo" + + . "github.com/tendermint/go-common" +) + +type LevelDB2 struct { + db *levigo.DB + ro *levigo.ReadOptions + wo *levigo.WriteOptions + woSync *levigo.WriteOptions +} + +func NewLevelDB2(name string) (*LevelDB2, error) { + dbPath := path.Join(name) + + opts := levigo.NewOptions() + opts.SetCache(levigo.NewLRUCache(1 << 30)) + opts.SetCreateIfMissing(true) + db, err := levigo.Open(dbPath, opts) + if err != nil { + return nil, err + } + ro := levigo.NewReadOptions() + wo := levigo.NewWriteOptions() + woSync := levigo.NewWriteOptions() + woSync.SetSync(true) + database := &LevelDB2{ + db: db, + ro: ro, + wo: wo, + woSync: woSync, + } + return database, nil +} + +func (db *LevelDB2) Get(key []byte) []byte { + res, err := db.db.Get(db.ro, key) + if err != nil { + PanicCrisis(err) + } + return res +} + +func (db *LevelDB2) Set(key []byte, value []byte) { + err := db.db.Put(db.wo, key, value) + if err != nil { + PanicCrisis(err) + } +} + +func (db *LevelDB2) SetSync(key []byte, value []byte) { + err := db.db.Put(db.woSync, key, value) + if err != nil { + PanicCrisis(err) + } +} + +func (db *LevelDB2) Delete(key []byte) { + err := db.db.Delete(db.wo, key) + if err != nil { + PanicCrisis(err) + } +} + +func (db *LevelDB2) DeleteSync(key []byte) { + err := db.db.Delete(db.woSync, key) + if err != nil { + PanicCrisis(err) + } +} + +func (db *LevelDB2) DB() *levigo.DB { + return db.db +} + +func (db *LevelDB2) Close() { + db.db.Close() + db.ro.Close() + db.wo.Close() + db.woSync.Close() +} + +func (db *LevelDB2) Print() { + iter := db.db.NewIterator(db.ro) + defer iter.Close() + for iter.Seek(nil); iter.Valid(); iter.Next() { + key := iter.Key() + value := iter.Value() + fmt.Printf("[%X]:\t[%X]\n", key, value) + } +} + +func (db *LevelDB2) NewBatch() Batch { + batch := levigo.NewWriteBatch() + return &levelDB2Batch{db, batch} +} + +//-------------------------------------------------------------------------------- + +type levelDB2Batch struct { + db *LevelDB2 + batch *levigo.WriteBatch +} + +func (mBatch *levelDB2Batch) Set(key, value []byte) { + mBatch.batch.Put(key, value) +} + +func (mBatch *levelDB2Batch) Delete(key []byte) { + mBatch.batch.Delete(key) +} + +func (mBatch *levelDB2Batch) Write() { + err := mBatch.db.db.Write(mBatch.db.wo, mBatch.batch) + if err != nil { + PanicCrisis(err) + } +} diff --git a/level_db2_test.go b/level_db2_test.go new file mode 100644 index 000000000..27a558407 --- /dev/null +++ b/level_db2_test.go @@ -0,0 +1,84 @@ +package db + +import ( + "bytes" + "fmt" + "testing" + + . "github.com/tendermint/go-common" +) + +func BenchmarkRandomReadsWrites2(b *testing.B) { + b.StopTimer() + + numItems := int64(1000000) + internal := map[int64]int64{} + for i := 0; i < int(numItems); i++ { + internal[int64(i)] = int64(0) + } + db, err := NewLevelDB2(Fmt("test_%x", RandStr(12))) + if err != nil { + b.Fatal(err.Error()) + return + } + + fmt.Println("ok, starting") + b.StartTimer() + + for i := 0; i < b.N; i++ { + // Write something + { + idx := (int64(RandInt()) % numItems) + internal[idx] += 1 + val := internal[idx] + idxBytes := int642Bytes(int64(idx)) + valBytes := int642Bytes(int64(val)) + //fmt.Printf("Set %X -> %X\n", idxBytes, valBytes) + db.Set( + idxBytes, + valBytes, + ) + } + // Read something + { + idx := (int64(RandInt()) % numItems) + val := internal[idx] + idxBytes := int642Bytes(int64(idx)) + valBytes := db.Get(idxBytes) + //fmt.Printf("Get %X -> %X\n", idxBytes, valBytes) + if val == 0 { + if !bytes.Equal(valBytes, nil) { + b.Errorf("Expected %X for %v, got %X", + nil, idx, valBytes) + break + } + } else { + if len(valBytes) != 8 { + b.Errorf("Expected length 8 for %v, got %X", + idx, valBytes) + break + } + valGot := bytes2Int64(valBytes) + if val != valGot { + b.Errorf("Expected %v for %v, got %v", + val, idx, valGot) + break + } + } + } + } + + db.Close() +} + +/* +func int642Bytes(i int64) []byte { + buf := make([]byte, 8) + binary.BigEndian.PutUint64(buf, uint64(i)) + return buf +} + +func bytes2Int64(buf []byte) int64 { + return int64(binary.BigEndian.Uint64(buf)) +} +*/ diff --git a/mem_db.go b/mem_db.go index b7d8918d4..d27159dab 100644 --- a/mem_db.go +++ b/mem_db.go @@ -2,10 +2,12 @@ package db import ( "fmt" + "sync" ) type MemDB struct { - db map[string][]byte + mtx sync.Mutex + db map[string][]byte } func NewMemDB() *MemDB { @@ -14,31 +16,91 @@ func NewMemDB() *MemDB { } func (db *MemDB) Get(key []byte) []byte { + db.mtx.Lock() + defer db.mtx.Unlock() return db.db[string(key)] } func (db *MemDB) Set(key []byte, value []byte) { + db.mtx.Lock() + defer db.mtx.Unlock() db.db[string(key)] = value } func (db *MemDB) SetSync(key []byte, value []byte) { + db.mtx.Lock() + defer db.mtx.Unlock() db.db[string(key)] = value } func (db *MemDB) Delete(key []byte) { + db.mtx.Lock() + defer db.mtx.Unlock() delete(db.db, string(key)) } func (db *MemDB) DeleteSync(key []byte) { + db.mtx.Lock() + defer db.mtx.Unlock() delete(db.db, string(key)) } func (db *MemDB) Close() { + db.mtx.Lock() + defer db.mtx.Unlock() db = nil } func (db *MemDB) Print() { + db.mtx.Lock() + defer db.mtx.Unlock() for key, value := range db.db { fmt.Printf("[%X]:\t[%X]\n", []byte(key), value) } } + +func (db *MemDB) NewBatch() Batch { + return &memDBBatch{db, nil} +} + +//-------------------------------------------------------------------------------- + +type memDBBatch struct { + db *MemDB + ops []operation +} + +type opType int + +const ( + opTypeSet = 1 + opTypeDelete = 2 +) + +type operation struct { + opType + key []byte + value []byte +} + +func (mBatch *memDBBatch) Set(key, value []byte) { + mBatch.ops = append(mBatch.ops, operation{opTypeSet, key, value}) +} + +func (mBatch *memDBBatch) Delete(key []byte) { + mBatch.ops = append(mBatch.ops, operation{opTypeDelete, key, nil}) +} + +func (mBatch *memDBBatch) Write() { + mBatch.db.mtx.Lock() + defer mBatch.db.mtx.Unlock() + + for _, op := range mBatch.ops { + if op.opType == opTypeSet { + mBatch.db.db[string(op.key)] = op.value + } else if op.opType == opTypeDelete { + delete(mBatch.db.db, string(op.key)) + } + } + +} From 5ab5538d6c4559991b9d468aa4c1824a2ab14763 Mon Sep 17 00:00:00 2001 From: Jae Kwon Date: Wed, 30 Nov 2016 20:15:29 -0800 Subject: [PATCH 2/4] Move cleveldb to own file w/ build tag condition 'gcc' --- level_db2.go => c_level_db.go | 46 +++++++++++++---------- level_db2_test.go => c_level_db_test.go | 4 +- db.go | 50 +++++++++++-------------- level_db.go => go_level_db.go | 44 ++++++++++++---------- level_db_test.go => go_level_db_test.go | 2 +- mem_db.go | 6 +++ 6 files changed, 84 insertions(+), 68 deletions(-) rename level_db2.go => c_level_db.go (63%) rename level_db2_test.go => c_level_db_test.go (95%) rename level_db.go => go_level_db.go (58%) rename level_db_test.go => go_level_db_test.go (96%) diff --git a/level_db2.go b/c_level_db.go similarity index 63% rename from level_db2.go rename to c_level_db.go index e3049aae3..638be41b1 100644 --- a/level_db2.go +++ b/c_level_db.go @@ -1,3 +1,5 @@ +// +build gcc + package db import ( @@ -9,15 +11,21 @@ import ( . "github.com/tendermint/go-common" ) -type LevelDB2 struct { +func init() { + registerDBCreator(CLevelDBBackendStr, func(name string, dir string) (DB, error) { + return NewCLevelDB(name, dir) + }, false) +} + +type CLevelDB struct { db *levigo.DB ro *levigo.ReadOptions wo *levigo.WriteOptions woSync *levigo.WriteOptions } -func NewLevelDB2(name string) (*LevelDB2, error) { - dbPath := path.Join(name) +func NewCLevelDB(name string, dir string) (*CLevelDB, error) { + dbPath := path.Join(dir, name+".db") opts := levigo.NewOptions() opts.SetCache(levigo.NewLRUCache(1 << 30)) @@ -30,7 +38,7 @@ func NewLevelDB2(name string) (*LevelDB2, error) { wo := levigo.NewWriteOptions() woSync := levigo.NewWriteOptions() woSync.SetSync(true) - database := &LevelDB2{ + database := &CLevelDB{ db: db, ro: ro, wo: wo, @@ -39,7 +47,7 @@ func NewLevelDB2(name string) (*LevelDB2, error) { return database, nil } -func (db *LevelDB2) Get(key []byte) []byte { +func (db *CLevelDB) Get(key []byte) []byte { res, err := db.db.Get(db.ro, key) if err != nil { PanicCrisis(err) @@ -47,46 +55,46 @@ func (db *LevelDB2) Get(key []byte) []byte { return res } -func (db *LevelDB2) Set(key []byte, value []byte) { +func (db *CLevelDB) Set(key []byte, value []byte) { err := db.db.Put(db.wo, key, value) if err != nil { PanicCrisis(err) } } -func (db *LevelDB2) SetSync(key []byte, value []byte) { +func (db *CLevelDB) SetSync(key []byte, value []byte) { err := db.db.Put(db.woSync, key, value) if err != nil { PanicCrisis(err) } } -func (db *LevelDB2) Delete(key []byte) { +func (db *CLevelDB) Delete(key []byte) { err := db.db.Delete(db.wo, key) if err != nil { PanicCrisis(err) } } -func (db *LevelDB2) DeleteSync(key []byte) { +func (db *CLevelDB) DeleteSync(key []byte) { err := db.db.Delete(db.woSync, key) if err != nil { PanicCrisis(err) } } -func (db *LevelDB2) DB() *levigo.DB { +func (db *CLevelDB) DB() *levigo.DB { return db.db } -func (db *LevelDB2) Close() { +func (db *CLevelDB) Close() { db.db.Close() db.ro.Close() db.wo.Close() db.woSync.Close() } -func (db *LevelDB2) Print() { +func (db *CLevelDB) Print() { iter := db.db.NewIterator(db.ro) defer iter.Close() for iter.Seek(nil); iter.Valid(); iter.Next() { @@ -96,27 +104,27 @@ func (db *LevelDB2) Print() { } } -func (db *LevelDB2) NewBatch() Batch { +func (db *CLevelDB) NewBatch() Batch { batch := levigo.NewWriteBatch() - return &levelDB2Batch{db, batch} + return &cLevelDBBatch{db, batch} } //-------------------------------------------------------------------------------- -type levelDB2Batch struct { - db *LevelDB2 +type cLevelDBBatch struct { + db *CLevelDB batch *levigo.WriteBatch } -func (mBatch *levelDB2Batch) Set(key, value []byte) { +func (mBatch *cLevelDBBatch) Set(key, value []byte) { mBatch.batch.Put(key, value) } -func (mBatch *levelDB2Batch) Delete(key []byte) { +func (mBatch *cLevelDBBatch) Delete(key []byte) { mBatch.batch.Delete(key) } -func (mBatch *levelDB2Batch) Write() { +func (mBatch *cLevelDBBatch) Write() { err := mBatch.db.db.Write(mBatch.db.wo, mBatch.batch) if err != nil { PanicCrisis(err) diff --git a/level_db2_test.go b/c_level_db_test.go similarity index 95% rename from level_db2_test.go rename to c_level_db_test.go index 27a558407..dbebcd902 100644 --- a/level_db2_test.go +++ b/c_level_db_test.go @@ -1,3 +1,5 @@ +// +build gcc + package db import ( @@ -16,7 +18,7 @@ func BenchmarkRandomReadsWrites2(b *testing.B) { for i := 0; i < int(numItems); i++ { internal[int64(i)] = int64(0) } - db, err := NewLevelDB2(Fmt("test_%x", RandStr(12))) + db, err := NewGoLevelDB(Fmt("test_%x", RandStr(12))) if err != nil { b.Fatal(err.Error()) return diff --git a/db.go b/db.go index ab38501e2..dac6df0cc 100644 --- a/db.go +++ b/db.go @@ -1,10 +1,6 @@ package db -import ( - "path" - - . "github.com/tendermint/go-common" -) +import . "github.com/tendermint/go-common" type DB interface { Get([]byte) []byte @@ -27,30 +23,28 @@ type Batch interface { //----------------------------------------------------------------------------- -// Database types -const DBBackendMemDB = "memdb" -const DBBackendLevelDB = "leveldb" -const DBBackendLevelDB2 = "leveldb2" +const ( + CLevelDBBackendStr = "goleveldb" + GoLevelDBBackendStr = "cleveldb" + MemDBBackendStr = "memdb" +) + +type dbCreator func(name string, dir string) (DB, error) + +var backends map[string]dbCreator + +func registerDBCreator(backend string, creator dbCreator, force bool) { + _, ok := backends[backend] + if !force && ok { + return + } + backends[backend] = creator +} func NewDB(name string, backend string, dir string) DB { - switch backend { - case DBBackendMemDB: - db := NewMemDB() - return db - case DBBackendLevelDB: - db, err := NewLevelDB(path.Join(dir, name+".db")) - if err != nil { - PanicCrisis(err) - } - return db - case DBBackendLevelDB2: - db, err := NewLevelDB2(path.Join(dir, name+".db")) - if err != nil { - PanicCrisis(err) - } - return db - default: - PanicSanity(Fmt("Unknown DB backend: %v", backend)) + db, err := backends[backend](name, dir) + if err != nil { + PanicSanity(Fmt("Error initializing DB: %v", err)) } - return nil + return db } diff --git a/level_db.go b/go_level_db.go similarity index 58% rename from level_db.go rename to go_level_db.go index 360362285..73c307b24 100644 --- a/level_db.go +++ b/go_level_db.go @@ -11,21 +11,27 @@ import ( . "github.com/tendermint/go-common" ) -type LevelDB struct { +func init() { + registerDBCreator(GoLevelDBBackendStr, func(name string, dir string) (DB, error) { + return NewGoLevelDB(name, dir) + }, false) +} + +type GoLevelDB struct { db *leveldb.DB } -func NewLevelDB(name string) (*LevelDB, error) { - dbPath := path.Join(name) +func NewGoLevelDB(name string, dir string) (*GoLevelDB, error) { + dbPath := path.Join(dir, name+".db") db, err := leveldb.OpenFile(dbPath, nil) if err != nil { return nil, err } - database := &LevelDB{db: db} + database := &GoLevelDB{db: db} return database, nil } -func (db *LevelDB) Get(key []byte) []byte { +func (db *GoLevelDB) Get(key []byte) []byte { res, err := db.db.Get(key, nil) if err != nil { if err == errors.ErrNotFound { @@ -37,43 +43,43 @@ func (db *LevelDB) Get(key []byte) []byte { return res } -func (db *LevelDB) Set(key []byte, value []byte) { +func (db *GoLevelDB) Set(key []byte, value []byte) { err := db.db.Put(key, value, nil) if err != nil { PanicCrisis(err) } } -func (db *LevelDB) SetSync(key []byte, value []byte) { +func (db *GoLevelDB) SetSync(key []byte, value []byte) { err := db.db.Put(key, value, &opt.WriteOptions{Sync: true}) if err != nil { PanicCrisis(err) } } -func (db *LevelDB) Delete(key []byte) { +func (db *GoLevelDB) Delete(key []byte) { err := db.db.Delete(key, nil) if err != nil { PanicCrisis(err) } } -func (db *LevelDB) DeleteSync(key []byte) { +func (db *GoLevelDB) DeleteSync(key []byte) { err := db.db.Delete(key, &opt.WriteOptions{Sync: true}) if err != nil { PanicCrisis(err) } } -func (db *LevelDB) DB() *leveldb.DB { +func (db *GoLevelDB) DB() *leveldb.DB { return db.db } -func (db *LevelDB) Close() { +func (db *GoLevelDB) Close() { db.db.Close() } -func (db *LevelDB) Print() { +func (db *GoLevelDB) Print() { iter := db.db.NewIterator(nil, nil) for iter.Next() { key := iter.Key() @@ -82,27 +88,27 @@ func (db *LevelDB) Print() { } } -func (db *LevelDB) NewBatch() Batch { +func (db *GoLevelDB) NewBatch() Batch { batch := new(leveldb.Batch) - return &levelDBBatch{db, batch} + return &goLevelDBBatch{db, batch} } //-------------------------------------------------------------------------------- -type levelDBBatch struct { - db *LevelDB +type goLevelDBBatch struct { + db *GoLevelDB batch *leveldb.Batch } -func (mBatch *levelDBBatch) Set(key, value []byte) { +func (mBatch *goLevelDBBatch) Set(key, value []byte) { mBatch.batch.Put(key, value) } -func (mBatch *levelDBBatch) Delete(key []byte) { +func (mBatch *goLevelDBBatch) Delete(key []byte) { mBatch.batch.Delete(key) } -func (mBatch *levelDBBatch) Write() { +func (mBatch *goLevelDBBatch) Write() { err := mBatch.db.db.Write(mBatch.batch, nil) if err != nil { PanicCrisis(err) diff --git a/level_db_test.go b/go_level_db_test.go similarity index 96% rename from level_db_test.go rename to go_level_db_test.go index 2a8e9ac1e..b7fe07bd7 100644 --- a/level_db_test.go +++ b/go_level_db_test.go @@ -17,7 +17,7 @@ func BenchmarkRandomReadsWrites(b *testing.B) { for i := 0; i < int(numItems); i++ { internal[int64(i)] = int64(0) } - db, err := NewLevelDB(Fmt("test_%x", RandStr(12))) + db, err := NewCLevelDB(Fmt("test_%x", RandStr(12))) if err != nil { b.Fatal(err.Error()) return diff --git a/mem_db.go b/mem_db.go index d27159dab..eb1e54b56 100644 --- a/mem_db.go +++ b/mem_db.go @@ -5,6 +5,12 @@ import ( "sync" ) +func init() { + registerDBCreator(MemDBBackendStr, func(name string, dir string) (DB, error) { + return NewMemDB(), nil + }, false) +} + type MemDB struct { mtx sync.Mutex db map[string][]byte From 5e2a1d3e300743380a329499804dde6bfb0af7d5 Mon Sep 17 00:00:00 2001 From: Jae Kwon Date: Wed, 30 Nov 2016 20:22:35 -0800 Subject: [PATCH 3/4] Fix tests; Support 'leveldb' for legacy --- c_level_db.go | 6 ++++-- c_level_db_test.go | 2 +- db.go | 3 ++- go_level_db.go | 6 ++++-- go_level_db_test.go | 2 +- 5 files changed, 12 insertions(+), 7 deletions(-) diff --git a/c_level_db.go b/c_level_db.go index 638be41b1..6c87c2949 100644 --- a/c_level_db.go +++ b/c_level_db.go @@ -12,9 +12,11 @@ import ( ) func init() { - registerDBCreator(CLevelDBBackendStr, func(name string, dir string) (DB, error) { + dbCreator := func(name string, dir string) (DB, error) { return NewCLevelDB(name, dir) - }, false) + } + registerDBCreator(LevelDBBackendStr, dbCreator, true) + registerDBCreator(CLevelDBBackendStr, dbCreator, false) } type CLevelDB struct { diff --git a/c_level_db_test.go b/c_level_db_test.go index dbebcd902..3baa8ba4c 100644 --- a/c_level_db_test.go +++ b/c_level_db_test.go @@ -18,7 +18,7 @@ func BenchmarkRandomReadsWrites2(b *testing.B) { for i := 0; i < int(numItems); i++ { internal[int64(i)] = int64(0) } - db, err := NewGoLevelDB(Fmt("test_%x", RandStr(12))) + db, err := NewGoLevelDB(Fmt("test_%x", RandStr(12)), "") if err != nil { b.Fatal(err.Error()) return diff --git a/db.go b/db.go index dac6df0cc..0649c2fdd 100644 --- a/db.go +++ b/db.go @@ -24,6 +24,7 @@ type Batch interface { //----------------------------------------------------------------------------- const ( + LevelDBBackendStr = "leveldb" // legacy, defaults to goleveldb. CLevelDBBackendStr = "goleveldb" GoLevelDBBackendStr = "cleveldb" MemDBBackendStr = "memdb" @@ -31,7 +32,7 @@ const ( type dbCreator func(name string, dir string) (DB, error) -var backends map[string]dbCreator +var backends = map[string]dbCreator{} func registerDBCreator(backend string, creator dbCreator, force bool) { _, ok := backends[backend] diff --git a/go_level_db.go b/go_level_db.go index 73c307b24..a16c5d9e0 100644 --- a/go_level_db.go +++ b/go_level_db.go @@ -12,9 +12,11 @@ import ( ) func init() { - registerDBCreator(GoLevelDBBackendStr, func(name string, dir string) (DB, error) { + dbCreator := func(name string, dir string) (DB, error) { return NewGoLevelDB(name, dir) - }, false) + } + registerDBCreator(LevelDBBackendStr, dbCreator, false) + registerDBCreator(GoLevelDBBackendStr, dbCreator, false) } type GoLevelDB struct { diff --git a/go_level_db_test.go b/go_level_db_test.go index b7fe07bd7..b5dad1163 100644 --- a/go_level_db_test.go +++ b/go_level_db_test.go @@ -17,7 +17,7 @@ func BenchmarkRandomReadsWrites(b *testing.B) { for i := 0; i < int(numItems); i++ { internal[int64(i)] = int64(0) } - db, err := NewCLevelDB(Fmt("test_%x", RandStr(12))) + db, err := NewCLevelDB(Fmt("test_%x", RandStr(12)), "") if err != nil { b.Fatal(err.Error()) return From 33e35c47326ffe1b2245b39c04125dba01e94d35 Mon Sep 17 00:00:00 2001 From: Ethan Buchman Date: Thu, 22 Dec 2016 15:44:51 -0500 Subject: [PATCH 4/4] go and c strings were swapped --- db.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/db.go b/db.go index 0649c2fdd..8ab1c43be 100644 --- a/db.go +++ b/db.go @@ -25,8 +25,8 @@ type Batch interface { const ( LevelDBBackendStr = "leveldb" // legacy, defaults to goleveldb. - CLevelDBBackendStr = "goleveldb" - GoLevelDBBackendStr = "cleveldb" + CLevelDBBackendStr = "cleveldb" + GoLevelDBBackendStr = "goleveldb" MemDBBackendStr = "memdb" )