// Delete removes a value with given key.
func (db *LevelDB) Delete(ctx storage.Context, tk storage.TKey) error {
if db == nil {
return fmt.Errorf("Can't call Delete on nil LevelDB")
}
if ctx == nil {
return fmt.Errorf("Received nil context in Delete()")
}
wo := db.options.WriteOptions
var err error
key := ctx.ConstructKey(tk)
if !ctx.Versioned() {
dvid.StartCgo()
err = db.ldb.Delete(wo, key)
dvid.StopCgo()
} else {
vctx, ok := ctx.(storage.VersionedCtx)
if !ok {
return fmt.Errorf("Non-versioned context that says it's versioned received in Delete(): %v", ctx)
}
tombstoneKey := vctx.TombstoneKey(tk)
batch := db.NewBatch(vctx).(*goBatch)
batch.WriteBatch.Delete(key)
batch.WriteBatch.Put(tombstoneKey, dvid.EmptyValue())
if err = batch.Commit(); err != nil {
dvid.Criticalf("Error on batch commit of Delete: %v\n", err)
err = fmt.Errorf("Error on batch commit of Delete: %v", err)
}
}
return err
}
// SendKeysInRange sends a range of keys spanning (kStart, kEnd). Values
// associated with the keys are not read. If the keys are versioned, only keys
// in the ancestor path of the current context's version will be returned.
// End of range is marked by a nil key.
func (db *LevelDB) SendKeysInRange(ctx storage.Context, kStart, kEnd storage.TKey, kch storage.KeyChan) error {
if db == nil {
return fmt.Errorf("Can't call SendKeysInRange on nil LevelDB")
}
if ctx == nil {
return fmt.Errorf("Received nil context in SendKeysInRange()")
}
ch := make(chan errorableKV)
done := make(chan struct{})
defer close(done)
// Run the range query on a potentially versioned key in a goroutine.
go func() {
if !ctx.Versioned() {
db.unversionedRange(ctx, kStart, kEnd, ch, done, true)
} else {
db.versionedRange(ctx.(storage.VersionedCtx), kStart, kEnd, ch, done, true)
}
}()
// Consume the keys.
for {
result := <-ch
if result.KeyValue == nil {
kch <- nil
return nil
}
if result.error != nil {
kch <- nil
return result.error
}
kch <- result.KeyValue.K
}
}
// Put writes a value with given key.
func (db *LevelDB) Put(ctx storage.Context, tk storage.TKey, v []byte) error {
if ctx == nil {
return fmt.Errorf("Received nil context in Put()")
}
wo := db.options.WriteOptions
var err error
key := ctx.ConstructKey(tk)
if !ctx.Versioned() {
dvid.StartCgo()
err = db.ldb.Put(wo, key, v)
dvid.StopCgo()
} else {
vctx, ok := ctx.(storage.VersionedCtx)
if !ok {
return fmt.Errorf("Non-versioned context that says it's versioned received in Put(): %v", ctx)
}
tombstoneKey := vctx.TombstoneKey(tk)
batch := db.NewBatch(vctx).(*goBatch)
batch.WriteBatch.Delete(tombstoneKey)
batch.WriteBatch.Put(key, v)
if err = batch.Commit(); err != nil {
batch.Close()
err = fmt.Errorf("Error on PUT: %v\n", err)
}
}
storage.StoreKeyBytesWritten <- len(key)
storage.StoreValueBytesWritten <- len(v)
return err
}
// GetRange returns a range of values spanning (kStart, kEnd) keys. These key-value
// pairs will be sorted in ascending key order. If the keys are versioned, all key-value
// pairs for the particular version will be returned.
func (db *LevelDB) GetRange(ctx storage.Context, kStart, kEnd storage.TKey) ([]*storage.TKeyValue, error) {
if ctx == nil {
return nil, fmt.Errorf("Received nil context in GetRange()")
}
ch := make(chan errorableKV)
// Run the range query on a potentially versioned key in a goroutine.
go func() {
if ctx == nil || !ctx.Versioned() {
db.unversionedRange(ctx, kStart, kEnd, ch, false)
} else {
db.versionedRange(ctx.(storage.VersionedCtx), kStart, kEnd, ch, false)
}
}()
// Consume the key-value pairs.
values := []*storage.TKeyValue{}
for {
result := <-ch
if result.KeyValue == nil {
return values, nil
}
if result.error != nil {
return nil, result.error
}
tk, err := ctx.TKeyFromKey(result.KeyValue.K)
if err != nil {
return nil, err
}
tkv := storage.TKeyValue{tk, result.KeyValue.V}
values = append(values, &tkv)
}
}
// Get returns a value given a key.
func (db *LevelDB) Get(ctx storage.Context, tk storage.TKey) ([]byte, error) {
if ctx == nil {
return nil, fmt.Errorf("Received nil context in Get()")
}
if ctx.Versioned() {
vctx, ok := ctx.(storage.VersionedCtx)
if !ok {
return nil, fmt.Errorf("Bad Get(): context is versioned but doesn't fulfill interface: %v", ctx)
}
// Get all versions of this key and return the most recent
// log.Printf(" basholeveldb versioned get of key %v\n", k)
values, err := db.getSingleKeyVersions(vctx, tk)
// log.Printf(" got back %v\n", values)
if err != nil {
return nil, err
}
kv, err := vctx.VersionedKeyValue(values)
// log.Printf(" after deversioning: %v\n", kv)
if kv != nil {
return kv.V, err
}
return nil, err
} else {
key := ctx.ConstructKey(tk)
ro := db.options.ReadOptions
// log.Printf(" basholeveldb unversioned get of key %v\n", key)
dvid.StartCgo()
v, err := db.ldb.Get(ro, key)
dvid.StopCgo()
storage.StoreValueBytesRead <- len(v)
return v, err
}
}
// KeysInRange returns a range of present keys spanning (kStart, kEnd). Values
// associated with the keys are not read. If the keys are versioned, only keys
// in the ancestor path of the current context's version will be returned.
func (db *LevelDB) KeysInRange(ctx storage.Context, kStart, kEnd storage.TKey) ([]storage.TKey, error) {
if db == nil {
return nil, fmt.Errorf("Can't call KeysInRange on nil LevelDB")
}
if ctx == nil {
return nil, fmt.Errorf("Received nil context in KeysInRange()")
}
ch := make(chan errorableKV)
// Run the range query on a potentially versioned key in a goroutine.
go func() {
if !ctx.Versioned() {
db.unversionedRange(ctx, kStart, kEnd, ch, true)
} else {
db.versionedRange(ctx.(storage.VersionedCtx), kStart, kEnd, ch, true)
}
}()
// Consume the keys.
values := []storage.TKey{}
for {
result := <-ch
if result.KeyValue == nil {
return values, nil
}
if result.error != nil {
return nil, result.error
}
tk, err := ctx.TKeyFromKey(result.KeyValue.K)
if err != nil {
return nil, err
}
values = append(values, tk)
}
}
// Get returns a value given a key.
func (db *KVAutobus) Get(ctx storage.Context, tk storage.TKey) ([]byte, error) {
if ctx == nil {
return nil, fmt.Errorf("Received nil context in Get()")
}
if ctx.Versioned() {
vctx, ok := ctx.(storage.VersionedCtx)
if !ok {
return nil, fmt.Errorf("Bad Get(): context is versioned but doesn't fulfill interface: %v", ctx)
}
// Get all versions of this key and return the most recent
// log.Printf(" kvautobus versioned get of key %v\n", k)
key := ctx.ConstructKey(tk)
dvid.Infof(" Get on key: %s\n", hex.EncodeToString(key))
values, err := db.getSingleKeyVersions(vctx, tk)
// log.Printf(" got back %v\n", values)
if err != nil {
return nil, err
}
kv, err := vctx.VersionedKeyValue(values)
// log.Printf(" after deversioning: %v\n", kv)
if kv != nil {
return kv.V, err
}
return nil, err
} else {
key := ctx.ConstructKey(tk)
// log.Printf(" kvautobus unversioned get of key %v\n", key)
v, err := db.RawGet(key)
storage.StoreValueBytesRead <- len(v)
return v, err
}
}
// DeleteRange removes all key-value pairs with keys in the given range.
func (db *LevelDB) DeleteRange(ctx storage.Context, kStart, kEnd storage.TKey) error {
if ctx == nil {
return fmt.Errorf("Received nil context in DeleteRange()")
}
// For leveldb, we just iterate over keys in range and delete each one using batch.
const BATCH_SIZE = 10000
batch := db.NewBatch(ctx).(*goBatch)
ch := make(chan errorableKV)
// Run the keys-only range query in a goroutine.
go func() {
if ctx == nil || !ctx.Versioned() {
db.unversionedRange(ctx, kStart, kEnd, ch, true)
} else {
db.versionedRange(ctx.(storage.VersionedCtx), kStart, kEnd, ch, true)
}
}()
// Consume the key-value pairs.
numKV := 0
for {
result := <-ch
if result.KeyValue == nil {
break
}
if result.error != nil {
return result.error
}
// The key coming down channel is not index but full key, so no need to construct key using context.
// If versioned, write a tombstone using current version id since we don't want to delete locked ancestors.
// If unversioned, just delete.
tk, err := ctx.TKeyFromKey(result.KeyValue.K)
if err != nil {
return err
}
batch.Delete(tk)
if (numKV+1)%BATCH_SIZE == 0 {
if err := batch.Commit(); err != nil {
batch.Close()
return fmt.Errorf("Error on batch DELETE at key-value pair %d: %v\n", numKV, err)
}
batch = db.NewBatch(ctx).(*goBatch)
}
numKV++
}
if numKV%BATCH_SIZE != 0 {
if err := batch.Commit(); err != nil {
batch.Close()
return fmt.Errorf("Error on last batch DELETE: %v\n", err)
}
}
dvid.Debugf("Deleted %d key-value pairs via delete range for %s.\n", numKV, ctx)
return nil
}
// DeleteRange removes all key-value pairs with keys in the given range. Versioned
// contexts cannot use immutable stores to delete ranges.
func (db *KVAutobus) DeleteRange(ctx storage.Context, kStart, kEnd storage.TKey) error {
if ctx == nil {
return fmt.Errorf("Received nil context in DeleteRange()")
}
if ctx.Versioned() {
return fmt.Errorf("DeleteRange() not supported for versioned contexts in immutable store")
}
keyBeg := ctx.ConstructKey(kStart)
keyEnd := ctx.ConstructKey(kEnd)
return db.deleteRange(keyBeg, keyEnd)
}
// ProcessRange sends a range of key-value pairs to chunk handlers. If the keys are versioned,
// only key-value pairs for kStart's version will be transmitted. If f returns an error, the
// function is immediately terminated and returns an error.
func (db *LevelDB) ProcessRange(ctx storage.Context, kStart, kEnd storage.TKey, op *storage.ChunkOp, f storage.ChunkFunc) error {
if db == nil {
return fmt.Errorf("Can't call ProcessRange on nil LevelDB")
}
if ctx == nil {
return fmt.Errorf("Received nil context in ProcessRange()")
}
ch := make(chan errorableKV)
done := make(chan struct{})
defer close(done)
// Run the range query on a potentially versioned key in a goroutine.
go func() {
if ctx == nil || !ctx.Versioned() {
db.unversionedRange(ctx, kStart, kEnd, ch, done, false)
} else {
db.versionedRange(ctx.(storage.VersionedCtx), kStart, kEnd, ch, done, false)
}
}()
// Consume the key-value pairs.
for {
result := <-ch
if result.KeyValue == nil {
return nil
}
if result.error != nil {
return result.error
}
if op != nil && op.Wg != nil {
op.Wg.Add(1)
}
tk, err := storage.TKeyFromKey(result.KeyValue.K)
if err != nil {
return err
}
tkv := storage.TKeyValue{tk, result.KeyValue.V}
chunk := &storage.Chunk{op, &tkv}
if err := f(chunk); err != nil {
return err
}
}
}