func (i *iterator) Next() bool { i.d.DB.View(func(tx *bolt.Tx) error { b := tx.Bucket(bucketName) c := b.Cursor() var key []byte var value []byte if !i.seeked { i.seeked = true if i.key == nil { key, value = c.First() } else { key, value = c.Seek(i.key) } } else { c.Seek(i.key) key, value = c.Next() } i.key = bytes.CloneBytes(key) i.value = bytes.CloneBytes(value) return nil }) return i.key != nil }
func (d *db) SeekReverse(startKey []byte) ([]byte, []byte, error) { var key, value []byte err := d.DB.View(func(tx *bolt.Tx) error { b := tx.Bucket(bucketName) c := b.Cursor() var k, v []byte if startKey == nil { k, v = c.Last() } else { c.Seek(startKey) k, v = c.Prev() } if k != nil { key, value = bytes.CloneBytes(k), bytes.CloneBytes(v) } return nil }) if err != nil { return nil, nil, errors.Trace(err) } if key == nil { return nil, nil, errors.Trace(engine.ErrNotFound) } return key, value, nil }
func (d *db) MultiSeek(keys [][]byte) []*engine.MSeekResult { res := make([]*engine.MSeekResult, 0, len(keys)) d.DB.View(func(tx *bolt.Tx) error { b := tx.Bucket(bucketName) c := b.Cursor() for _, key := range keys { var k, v []byte if key == nil { k, v = c.First() } else { k, v = c.Seek(key) } r := &engine.MSeekResult{} if k == nil { r.Err = engine.ErrNotFound } else { r.Key, r.Value, r.Err = bytes.CloneBytes(k), bytes.CloneBytes(v), nil } res = append(res, r) } return nil }) return res }
func (i *iterator) Seek(startKey []byte) bool { i.d.DB.View(func(tx *bolt.Tx) error { b := tx.Bucket(bucketName) c := b.Cursor() var key []byte var value []byte key, value = c.Seek(startKey) i.key = bytes.CloneBytes(key) i.value = bytes.CloneBytes(value) return nil }) return i.key != nil }
func (it *dbIter) Next() (kv.Iterator, error) { encKey := codec.EncodeBytes(nil, it.startKey) var retErr error var engineIter engine.Iterator for { var err error engineIter, err = it.s.internalSeek(encKey) if err != nil { it.valid = false retErr = err break } metaKey := engineIter.Key() // Get real key from metaKey key, _, err := MvccDecode(metaKey) if err != nil { // It's not a valid metaKey, maybe overflow (other data). it.valid = false break } // Get kv pair. val, err := it.s.MvccGet(key, it.exceptedVersion) if err != nil && !errors2.ErrorEqual(err, kv.ErrNotExist) { // Get this version error it.valid = false retErr = err break } if val != nil { it.k = bytes.CloneBytes(key) it.v = bytes.CloneBytes(val) it.startKey = key.Next() break } // Current key's all versions are deleted, just go next key. encKey = codec.EncodeBytes(nil, key.Next()) } return it, errors.Trace(retErr) }
func (d *db) Get(key []byte) ([]byte, error) { var value []byte err := d.DB.View(func(tx *bolt.Tx) error { b := tx.Bucket(bucketName) v := b.Get(key) if v == nil { return errors.Trace(engine.ErrNotFound) } value = bytes.CloneBytes(v) return nil }) return value, errors.Trace(err) }
func (gc *localstoreCompactor) getAllVersions(k kv.Key) ([]kv.EncodedKey, error) { startKey := MvccEncodeVersionKey(k, kv.MaxVersion) endKey := MvccEncodeVersionKey(k, kv.MinVersion) it, err := gc.db.Seek(startKey) if err != nil { return nil, errors.Trace(err) } defer it.Release() var ret []kv.EncodedKey for it.Next() { if kv.EncodedKey(it.Key()).Cmp(endKey) < 0 { ret = append(ret, bytes.CloneBytes(kv.EncodedKey(it.Key()))) } } return ret, nil }
func (gc *localstoreCompactor) getAllVersions(key kv.Key) ([]kv.EncodedKey, error) { var keys []kv.EncodedKey k := key for ver := kv.MaxVersion; ver.Ver > 0; ver.Ver-- { mvccK, _, err := gc.db.Seek(MvccEncodeVersionKey(key, ver)) if terror.ErrorEqual(err, engine.ErrNotFound) { break } if err != nil { return nil, errors.Trace(err) } k, ver, err = MvccDecode(mvccK) if k.Cmp(key) != 0 { break } if err != nil { return nil, errors.Trace(err) } keys = append(keys, bytes.CloneBytes(mvccK)) } return keys, nil }
func (s *dbSnapshot) MvccGet(k kv.Key, ver kv.Version) ([]byte, error) { // engine Snapshot return nil, nil for value not found, // so here we will check nil and return kv.ErrNotExist. // get newest version, (0, MaxUint64) // Key arrangement: // Key -> META // ... // Key_ver // Key_ver-1 // Key_ver-2 // ... // Key_ver-n // Key_0 // NextKey -> META // NextKey_xxx startKey := MvccEncodeVersionKey(k, ver) endKey := MvccEncodeVersionKey(k, kv.MinVersion) it, err := s.internalSeek(startKey) if err != nil { return nil, errors.Trace(err) } var rawKey []byte var v []byte // Check if the scan is not exceed this key's all versions and the value is not // tombstone. if kv.EncodedKey(it.Key()).Cmp(endKey) < 0 && !isTombstone(it.Value()) { rawKey = it.Key() v = it.Value() } // No such key (or it's tombstone). if rawKey == nil { return nil, kv.ErrNotExist } return bytes.CloneBytes(v), nil }