func sequenceCacheKeyPrint(key roachpb.Key) string {
b, id, err := encoding.DecodeBytes([]byte(key), nil)
if err != nil {
return fmt.Sprintf("/%q/err:%v", key, err)
}
if len(b) == 0 {
return fmt.Sprintf("/%q", id)
}
b, epoch, err := encoding.DecodeUint32Decreasing(b)
if err != nil {
return fmt.Sprintf("/%q/err:%v", id, err)
}
_, seq, err := encoding.DecodeUint32Decreasing(b)
if err != nil {
return fmt.Sprintf("/%q/epoch:%d/err:%v", id, epoch, err)
}
return fmt.Sprintf("/%q/epoch:%d/seq:%d", id, epoch, seq)
}
// mvccDecodeKey decodes encodedKey into key and Timestamp. The final
// returned bool is true if this is an MVCC value and false if this is
// MVCC metadata. Note that the returned key is exactly the value of
// key passed to mvccEncodeKey. A separate DecodeBinary step must be
// carried out to decode it if necessary.
// If a decode process fails, a panic ensues.
func mvccDecodeKey(encodedKey []byte) (Key, proto.Timestamp, bool) {
tsBytes, _ := encoding.DecodeBinary(encodedKey)
key := encodedKey[:len(encodedKey)-len(tsBytes)]
if len(tsBytes) == 0 {
return key, proto.Timestamp{}, false
}
tsBytes, walltime := encoding.DecodeUint64Decreasing(tsBytes)
tsBytes, logical := encoding.DecodeUint32Decreasing(tsBytes)
if len(tsBytes) > 0 {
panic(fmt.Sprintf("leftover bytes on mvcc key decode: %v", tsBytes))
}
return key, proto.Timestamp{WallTime: int64(walltime), Logical: int32(logical)}, true
}
func decodeSequenceCacheKey(key roachpb.Key, dest []byte) ([]byte, uint32, uint32, error) {
// TODO(tschottdorf): redundant check.
if !bytes.HasPrefix(key, keys.LocalRangeIDPrefix) {
return nil, 0, 0, util.Errorf("key %s does not have %s prefix", key, keys.LocalRangeIDPrefix)
}
// Cut the prefix and the Range ID.
b := key[len(keys.LocalRangeIDPrefix):]
b, _, err := encoding.DecodeUvarint(b)
if err != nil {
return nil, 0, 0, err
}
if !bytes.HasPrefix(b, keys.LocalSequenceCacheSuffix) {
return nil, 0, 0, util.Errorf("key %s does not contain the sequence cache suffix %s",
key, keys.LocalSequenceCacheSuffix)
}
// Cut the sequence cache suffix.
b = b[len(keys.LocalSequenceCacheSuffix):]
// Decode the id.
b, id, err := encoding.DecodeBytes(b, dest)
if err != nil {
return nil, 0, 0, err
}
// Decode the epoch.
b, epoch, err := encoding.DecodeUint32Decreasing(b)
if err != nil {
return nil, 0, 0, err
}
// Decode the sequence number.
b, seq, err := encoding.DecodeUint32Decreasing(b)
if err != nil {
return nil, 0, 0, err
}
if len(b) > 0 {
return nil, 0, 0, util.Errorf("key %q has leftover bytes after decode: %s; indicates corrupt key",
key, b)
}
return id, epoch, seq, nil
}
