// Both lock and unlock are used for simulating scenario of percolator papers.
func (s *dbStore) tryConditionLockKey(tid uint64, key string, snapshotVal []byte) error {
s.mu.Lock()
defer s.mu.Unlock()
if _, ok := s.keysLocked[key]; ok {
return errors.Trace(kv.ErrLockConflict)
}
metaKey := codec.EncodeBytes(nil, []byte(key))
currValue, err := s.db.Get(metaKey)
if errors2.ErrorEqual(err, kv.ErrNotExist) || currValue == nil {
// If it's a new key, we won't need to check its version
return nil
}
if err != nil {
return errors.Trace(err)
}
_, ver, err := codec.DecodeUint(currValue)
if err != nil {
return errors.Trace(err)
}
// If there's newer version of this key, returns error.
if ver > tid {
log.Warnf("txn:%d, tryLockKey condition not match for key %s, currValue:%q, snapshotVal:%q", tid, key, currValue, snapshotVal)
return errors.Trace(kv.ErrConditionNotMatch)
}
s.keysLocked[key] = tid
return nil
}
func (t *TxStructure) decodeHashDataKey(ek kv.Key) ([]byte, []byte, error) {
var (
key []byte
field []byte
err error
tp uint64
)
if !bytes.HasPrefix(ek, t.prefix) {
return nil, nil, errors.New("invalid encoded hash data key prefix")
}
ek = ek[len(t.prefix):]
ek, key, err = codec.DecodeBytes(ek)
if err != nil {
return nil, nil, errors.Trace(err)
}
ek, tp, err = codec.DecodeUint(ek)
if err != nil {
return nil, nil, errors.Trace(err)
} else if TypeFlag(tp) != HashData {
return nil, nil, errors.Errorf("invalid encoded hash data key flag %c", byte(tp))
}
_, field, err = codec.DecodeBytes(ek)
return key, field, errors.Trace(err)
}
func (e *Evaluator) evalUint(val []byte) (types.Datum, error) {
var d types.Datum
_, u, err := codec.DecodeUint(val)
if err != nil {
return d, ErrInvalid.Gen("invalid uint % x", val)
}
d.SetUint64(u)
return d, nil
}
// Both lock and unlock are used for simulating scenario of percolator papers.
func (s *dbStore) tryConditionLockKey(tid uint64, key string) error {
metaKey := codec.EncodeBytes(nil, []byte(key))
s.mu.Lock()
defer s.mu.Unlock()
if s.closed {
return errors.Trace(ErrDBClosed)
}
if _, ok := s.keysLocked[key]; ok {
return errors.Trace(kv.ErrLockConflict)
}
currValue, err := s.db.Get(metaKey)
if terror.ErrorEqual(err, kv.ErrNotExist) {
s.keysLocked[key] = tid
return nil
}
if err != nil {
return errors.Trace(err)
}
// key not exist.
if currValue == nil {
s.keysLocked[key] = tid
return nil
}
_, ver, err := codec.DecodeUint(currValue)
if err != nil {
return errors.Trace(err)
}
// If there's newer version of this key, returns error.
if ver > tid {
log.Warnf("txn:%d, tryLockKey condition not match for key %s, currValue:%q", tid, key, currValue)
return errors.Trace(kv.ErrConditionNotMatch)
}
s.keysLocked[key] = tid
return nil
}
