// Increment fetches the varint encoded int64 value specified by key
// and adds "inc" to it then re-encodes as varint. The newly incremented
// value is returned.
func (mvcc *MVCC) Increment(key Key, timestamp proto.Timestamp, txnID []byte, inc int64) (int64, error) {
// Handle check for non-existence of key. In order to detect
// the potential write intent by another concurrent transaction
// with a newer timestamp, we need to use the max timestamp
// while reading.
val, err := mvcc.Get(key, proto.MaxTimestamp, txnID)
if err != nil {
return 0, err
}
var int64Val int64
// If the value exists, attempt to decode it as a varint.
if len(val.Bytes) != 0 {
decoded, err := encoding.Decode(key, val.Bytes)
if err != nil {
return 0, err
}
if _, ok := decoded.(int64); !ok {
return 0, util.Errorf("received value of wrong type %v", reflect.TypeOf(decoded))
}
int64Val = decoded.(int64)
}
// Check for overflow and underflow.
if encoding.WillOverflow(int64Val, inc) {
return 0, util.Errorf("key %q with value %d incremented by %d results in overflow", key, int64Val, inc)
}
if inc == 0 {
return int64Val, nil
}
r := int64Val + inc
encoded, err := encoding.Encode(key, r)
if err != nil {
return 0, util.Errorf("error encoding %d", r)
}
err = mvcc.Put(key, timestamp, proto.Value{Bytes: encoded, Timestamp: timestamp}, txnID)
if err != nil {
return 0, err
}
return r, nil
}
// Increment fetches the varint encoded int64 value specified by key
// and adds "inc" to it then re-encodes as varint. The newly incremented
// value is returned.
func Increment(engine Engine, key Key, inc int64) (int64, error) {
// First retrieve existing value.
val, err := engine.Get(key)
if err != nil {
return 0, err
}
var int64Val int64
// If the value exists, attempt to decode it as a varint.
if len(val) != 0 {
decoded, err := encoding.Decode(key, val)
if err != nil {
return 0, err
}
if _, ok := decoded.(int64); !ok {
return 0, util.Errorf("received value of wrong type %v", reflect.TypeOf(decoded))
}
int64Val = decoded.(int64)
}
// Check for overflow and underflow.
if encoding.WillOverflow(int64Val, inc) {
return 0, util.Errorf("key %q with value %d incremented by %d results in overflow", key, int64Val, inc)
}
if inc == 0 {
return int64Val, nil
}
r := int64Val + inc
encoded, err := encoding.Encode(key, r)
if err != nil {
return 0, util.Errorf("error encoding %d", r)
}
if err = engine.Put(key, encoded); err != nil {
return 0, err
}
return r, nil
}