// KeysInRange returns a range of type-specific key components spanning (TkBeg, TkEnd).
func (db *BigTable) KeysInRange(ctx storage.Context, TkBeg, TkEnd storage.TKey) ([]storage.TKey, error) {
if db == nil {
return nil, fmt.Errorf("Can't call KeysInRange() on nil BigTable")
}
if ctx == nil {
return nil, fmt.Errorf("Received nil context in KeysInRange()")
}
tKeys := make([]storage.TKey, 0)
unvKeyBeg, _, err := ctx.SplitKey(TkBeg)
if err != nil {
dvid.Errorf("Error in KeysInRange(): %v\n", err)
}
unvKeyEnd, _, err := ctx.SplitKey(TkEnd)
if err != nil {
dvid.Errorf("Error in KeysInRange(): %v\n", err)
}
rr := api.NewRange(encodeKey(unvKeyBeg), encodeKey(unvKeyEnd))
err = tbl.ReadRows(db.ctx, rr, func(r api.Row) bool {
if len(r[familyName]) == 0 {
dvid.Errorf("Error in KeysInRange(): row has no columns")
return false
}
unvKeyRow, err := decodeKey(r.Key())
if err != nil {
dvid.Errorf("Error in KeysInRange(): %v\n", err)
return false
}
verKeyRow, err := decodeKey(r[familyName][0].Column)
if err != nil {
dvid.Errorf("Error in KeysInRange(): %v\n", err)
return false
}
fullKey := storage.MergeKey(unvKeyRow, verKeyRow)
tkey, err := storage.TKeyFromKey(fullKey)
if err != nil {
dvid.Errorf("Error in KeysInRange(): %v\n", err)
return false
}
tKeys = append(tKeys, tkey)
return true // keep going
}, api.RowFilter(api.StripValueFilter()))
return tKeys, err
}
// GetRange returns a range of values spanning (TkBeg, kEnd) keys.
func (db *BigTable) GetRange(ctx storage.Context, TkBeg, TkEnd storage.TKey) ([]*storage.TKeyValue, error) {
if db == nil {
return nil, fmt.Errorf("Can't call GetRange() on nil BigTable")
}
if ctx == nil {
return nil, fmt.Errorf("Received nil context in GetRange()")
}
unvKeyBeg, _, err := ctx.SplitKey(TkBeg)
if err != nil {
dvid.Errorf("Error in GetRange(): %v\n", err)
}
unvKeyEnd, _, err := ctx.SplitKey(TkEnd)
if err != nil {
dvid.Errorf("Error in GetRange(): %v\n", err)
}
tKeyValues := make([]*storage.TKeyValue, 0)
rr := api.NewRange(encodeKey(unvKeyBeg), encodeKey(unvKeyEnd))
err = tbl.ReadRows(db.ctx, rr, func(r api.Row) bool {
unvKeyRow, err := decodeKey(r.Key())
if err != nil {
dvid.Errorf("Error in GetRange() decodeKey(r.Key()): %v\n", err)
return false
}
// dvid.Infof("GetRange() with row key= %v", r.Key())
for _, readItem := range r[familyName] {
verKey, err := decodeKey(readItem.Column)
if err != nil {
dvid.Errorf("Error in GetRange() decodeKey(readItem.Column): %v\n", err)
return false
}
fullKey := storage.MergeKey(unvKeyRow, verKey)
// dvid.Infof("colum key= %v , timestamp = %v", verKey, readItem.Timestamp)
tkey, err := storage.TKeyFromKey(fullKey)
if err != nil {
dvid.Errorf("Error in GetRange() storage.TKeyFromKey(fullKey): %v\n", err)
return false
}
kv := storage.TKeyValue{tkey, readItem.Value}
tKeyValues = append(tKeyValues, &kv)
}
return true // keep going
})
return tKeyValues, err
}
// SendKeysInRange sends a range of full keys down a key channel.
func (db *BigTable) SendKeysInRange(ctx storage.Context, TkBeg, TkEnd storage.TKey, ch storage.KeyChan) error {
if db == nil {
return fmt.Errorf("Can't call SendKeysInRange() on nil BigTable")
}
if ctx == nil {
return fmt.Errorf("Received nil context in SendKeysInRange()")
}
unvKeyBeg, _, err := ctx.SplitKey(TkBeg)
if err != nil {
dvid.Errorf("Error in SendKeysInRange(): %v\n", err)
}
unvKeyEnd, _, err := ctx.SplitKey(TkEnd)
if err != nil {
dvid.Errorf("Error in SendKeysInRange(): %v\n", err)
}
rr := api.NewRange(encodeKey(unvKeyBeg), encodeKey(unvKeyEnd))
err = tbl.ReadRows(db.ctx, rr, func(r api.Row) bool {
unvKeyRow, err := decodeKey(r.Key())
if err != nil {
dvid.Errorf("Error in SendKeysInRange(): %v\n", err)
return false
}
//I need the versioned key to merged it with the unversioned
// and send it throu the channel
for _, readItem := range r[familyName] {
verKey, err := decodeKey(readItem.Column)
if err != nil {
dvid.Errorf("Error in SendKeysInRange(): %v\n", err)
return false
}
fullKey := storage.MergeKey(unvKeyRow, verKey)
ch <- fullKey
}
return true // keep going
}, api.RowFilter(api.StripValueFilter()))
return err
}
// RawRangeQuery sends a range of full keys. This is to be used for low-level data
// retrieval like DVID-to-DVID communication and should not be used by data type
// implementations if possible because each version's key-value pairs are sent
// without filtering by the current version and its ancestor graph. A nil is sent
// down the channel when the range is complete.
func (db *BigTable) RawRangeQuery(kStart, kEnd storage.Key, keysOnly bool, out chan *storage.KeyValue, cancel <-chan struct{}) error {
if db == nil {
return fmt.Errorf("Can't call RawRangeQuery() on nil BigTable")
}
unvKeyBeg, verKeyBeg, err := storage.SplitKey(kStart)
if err != nil {
dvid.Errorf("Error in RawRangeQuery(): %v\n", err)
return err
}
unvKeyEnd, verKeyEnd, err := storage.SplitKey(kEnd)
if err != nil {
dvid.Errorf("Error in RawRangeQuery(): %v\n", err)
return err
}
rr := api.NewRange(encodeKey(unvKeyBeg), encodeKey(unvKeyEnd))
err = tbl.ReadRows(db.ctx, rr, func(r api.Row) bool {
if cancel != nil {
select {
case <-cancel:
out <- nil
return nil
default:
}
}
unvKeyRow, err := decodeKey(r.Key())
if err != nil {
dvid.Errorf("Error in RawRangeQuery(): %v\n", err)
return false
}
//I need the versioned key to merged it with the unversioned
// and send it throu the channel
for _, readItem := range r[familyName] {
verKey, err := decodeKey(readItem.Column)
if err != nil {
dvid.Errorf("Error in RawRangeQuery(): %v\n", err)
return false
}
lowerLimit := bytes.Equal(unvKeyBeg, unvKeyRow) && bytes.Compare(verKey, verKeyBeg) == -1
upperLimit := bytes.Equal(unvKeyEnd, unvKeyRow) && bytes.Compare(verKey, verKeyEnd) >= 0
if lowerLimit || upperLimit {
continue
}
fullKey := storage.MergeKey(unvKeyRow, verKey)
kv := storage.KeyValue{fullKey, readItem.Value}
out <- &kv
}
return true // keep going
})
return nil
}
// ProcessRange sends a range of type key-value pairs to type-specific chunk handlers,
// allowing chunk processing to be concurrent with key-value sequential reads.
// Since the chunks are typically sent during sequential read iteration, the
// receiving function can be organized as a pool of chunk handling goroutines.
// See datatype/imageblk.ProcessChunk() for an example.
func (db *BigTable) ProcessRange(ctx storage.Context, TkBeg, TkEnd storage.TKey, op *storage.ChunkOp, f storage.ChunkFunc) error {
if db == nil {
return fmt.Errorf("Can't call ProcessRange() on nil BigTable")
}
if ctx == nil {
return fmt.Errorf("Received nil context in ProcessRange()")
}
unvKeyBeg, verKey, err := ctx.SplitKey(TkBeg)
if err != nil {
dvid.Errorf("Error in ProcessRange(): %v\n", err)
}
unvKeyEnd, _, err := ctx.SplitKey(TkEnd)
if err != nil {
dvid.Errorf("Error in ProcessRange(): %v\n", err)
}
rr := api.NewRange(encodeKey(unvKeyBeg), encodeKey(unvKeyEnd))
err = tbl.ReadRows(db.ctx, rr, func(r api.Row) bool {
if len(r[familyName]) == 0 {
dvid.Errorf("Error in KeysInRange(): row has no columns")
return false
}
unvKeyRow, err := decodeKey(r.Key())
if err != nil {
dvid.Errorf("Error in ProcessRange(): %v\n", err)
return false
}
verKeyRow, err := decodeKey(r[familyName][0].Column)
if err != nil {
dvid.Errorf("Error in ProcessRange(): %v\n", err)
return false
}
fullKey := storage.MergeKey(unvKeyRow, verKeyRow)
tkey, err := storage.TKeyFromKey(fullKey)
if err != nil {
dvid.Errorf("Error in ProcessRange(): %v\n", err)
return false
}
if op.Wg != nil {
op.Wg.Add(1)
}
value, err := getValue(r, verKey)
if err != nil {
dvid.Errorf("Error in ProcessRange(): %v\n", err)
return false
}
tkv := storage.TKeyValue{tkey, value}
chunk := &storage.Chunk{op, &tkv}
if err := f(chunk); err != nil {
dvid.Errorf("Error in ProcessRange(): %v\n", err)
return false
}
return true // keep going
})
return err
}
