// DecodeDataKey decodes a time series key into its components.
func DecodeDataKey(key roachpb.Key) (string, string, Resolution, int64, error) {
// Detect and remove prefix.
remainder := key
if !bytes.HasPrefix(remainder, keyDataPrefix) {
return "", "", 0, 0, util.Errorf("malformed time series data key %v: improper prefix", key)
}
remainder = remainder[len(keyDataPrefix):]
// Decode series name.
remainder, name, err := encoding.DecodeBytesAscending(remainder, nil)
if err != nil {
return "", "", 0, 0, err
}
// Decode resolution.
remainder, resolutionInt, err := encoding.DecodeVarintAscending(remainder)
if err != nil {
return "", "", 0, 0, err
}
resolution := Resolution(resolutionInt)
// Decode timestamp.
remainder, timeslot, err := encoding.DecodeVarintAscending(remainder)
if err != nil {
return "", "", 0, 0, err
}
timestamp := timeslot * resolution.KeyDuration()
// The remaining bytes are the source.
source := remainder
return string(name), string(source), resolution, timestamp, nil
}
func decodeKeyPrint(key roachpb.Key) string {
var buf bytes.Buffer
for k := 0; len(key) > 0; k++ {
var err error
switch encoding.PeekType(key) {
case encoding.Null:
key, _ = encoding.DecodeIfNull(key)
fmt.Fprintf(&buf, "/NULL")
case encoding.NotNull:
key, _ = encoding.DecodeIfNotNull(key)
fmt.Fprintf(&buf, "/#")
case encoding.Int:
var i int64
key, i, err = encoding.DecodeVarintAscending(key)
if err == nil {
fmt.Fprintf(&buf, "/%d", i)
}
case encoding.Float:
var f float64
key, f, err = encoding.DecodeFloatAscending(key, nil)
if err == nil {
fmt.Fprintf(&buf, "/%f", f)
}
case encoding.Bytes:
var s string
key, s, err = encoding.DecodeStringAscending(key, nil)
if err == nil {
fmt.Fprintf(&buf, "/%q", s)
}
case encoding.BytesDesc:
var s string
key, s, err = encoding.DecodeStringDescending(key, nil)
if err == nil {
fmt.Fprintf(&buf, "/%q", s)
}
case encoding.Time:
var t time.Time
key, t, err = encoding.DecodeTimeAscending(key)
if err == nil {
fmt.Fprintf(&buf, "/%s", t.UTC().Format(time.UnixDate))
}
case encoding.TimeDesc:
var t time.Time
key, t, err = encoding.DecodeTimeDescending(key)
if err == nil {
fmt.Fprintf(&buf, "/%s", t.UTC().Format(time.UnixDate))
}
default:
// This shouldn't ever happen, but if it does let the loop exit.
fmt.Fprintf(&buf, "/%q", []byte(key))
key = nil
}
if err != nil {
fmt.Fprintf(&buf, "/<%v>", err)
continue
}
}
return buf.String()
}
// decodeDataKeySuffix decodes a time series key into its components.
func decodeDataKeySuffix(key roachpb.Key) (string, string, Resolution, int64, error) {
// Decode series name.
remainder, name, err := encoding.DecodeBytesAscending(key, nil)
if err != nil {
return "", "", 0, 0, err
}
// Decode resolution.
remainder, resolutionInt, err := encoding.DecodeVarintAscending(remainder)
if err != nil {
return "", "", 0, 0, err
}
resolution := Resolution(resolutionInt)
// Decode timestamp.
remainder, timeslot, err := encoding.DecodeVarintAscending(remainder)
if err != nil {
return "", "", 0, 0, err
}
timestamp := timeslot * resolution.KeyDuration()
// The remaining bytes are the source.
source := remainder
return string(name), string(source), resolution, timestamp, nil
}
func localRangeIDKeyPrint(key roachpb.Key) string {
var buf bytes.Buffer
if encoding.PeekType(key) != encoding.Int {
return fmt.Sprintf("/err<%q>", []byte(key))
}
// Get the rangeID.
key, i, err := encoding.DecodeVarintAscending(key)
if err != nil {
return fmt.Sprintf("/err<%v:%q>", err, []byte(key))
}
fmt.Fprintf(&buf, "/%d", i)
// Print and remove the rangeID infix specifier.
if len(key) != 0 {
fmt.Fprintf(&buf, "/%s", string(key[0]))
key = key[1:]
}
// Get the suffix.
hasSuffix := false
for _, s := range rangeIDSuffixDict {
if bytes.HasPrefix(key, s.suffix) {
fmt.Fprintf(&buf, "/%s", s.name)
key = key[len(s.suffix):]
if s.ppFunc != nil && len(key) != 0 {
fmt.Fprintf(&buf, "%s", s.ppFunc(key))
return buf.String()
}
hasSuffix = true
break
}
}
// Get the encode values.
if hasSuffix {
fmt.Fprintf(&buf, "%s", decodeKeyPrint(key))
} else {
fmt.Fprintf(&buf, "%q", []byte(key))
}
return buf.String()
}
// DecodeTableKey decodes a table key/value.
func DecodeTableKey(
a *DatumAlloc, valType parser.Datum, key []byte, dir encoding.Direction,
) (parser.Datum, []byte, error) {
if (dir != encoding.Ascending) && (dir != encoding.Descending) {
return nil, nil, util.Errorf("invalid direction: %d", dir)
}
var isNull bool
if key, isNull = encoding.DecodeIfNull(key); isNull {
return parser.DNull, key, nil
}
var rkey []byte
var err error
switch valType.(type) {
case *parser.DBool:
var i int64
if dir == encoding.Ascending {
rkey, i, err = encoding.DecodeVarintAscending(key)
} else {
rkey, i, err = encoding.DecodeVarintDescending(key)
}
// No need to chunk allocate DBool as MakeDBool returns either
// parser.DBoolTrue or parser.DBoolFalse.
return parser.MakeDBool(parser.DBool(i != 0)), rkey, err
case *parser.DInt:
var i int64
if dir == encoding.Ascending {
rkey, i, err = encoding.DecodeVarintAscending(key)
} else {
rkey, i, err = encoding.DecodeVarintDescending(key)
}
return a.NewDInt(parser.DInt(i)), rkey, err
case *parser.DFloat:
var f float64
if dir == encoding.Ascending {
rkey, f, err = encoding.DecodeFloatAscending(key)
} else {
rkey, f, err = encoding.DecodeFloatDescending(key)
}
return a.NewDFloat(parser.DFloat(f)), rkey, err
case *parser.DDecimal:
var d *inf.Dec
if dir == encoding.Ascending {
rkey, d, err = encoding.DecodeDecimalAscending(key, nil)
} else {
rkey, d, err = encoding.DecodeDecimalDescending(key, nil)
}
dd := a.NewDDecimal(parser.DDecimal{})
dd.Set(d)
return dd, rkey, err
case *parser.DString:
var r string
if dir == encoding.Ascending {
rkey, r, err = encoding.DecodeUnsafeStringAscending(key, nil)
} else {
rkey, r, err = encoding.DecodeUnsafeStringDescending(key, nil)
}
return a.NewDString(parser.DString(r)), rkey, err
case *parser.DBytes:
var r []byte
if dir == encoding.Ascending {
rkey, r, err = encoding.DecodeBytesAscending(key, nil)
} else {
rkey, r, err = encoding.DecodeBytesDescending(key, nil)
}
return a.NewDBytes(parser.DBytes(r)), rkey, err
case *parser.DDate:
var t int64
if dir == encoding.Ascending {
rkey, t, err = encoding.DecodeVarintAscending(key)
} else {
rkey, t, err = encoding.DecodeVarintDescending(key)
}
return a.NewDDate(parser.DDate(t)), rkey, err
case *parser.DTimestamp:
var t time.Time
if dir == encoding.Ascending {
rkey, t, err = encoding.DecodeTimeAscending(key)
} else {
rkey, t, err = encoding.DecodeTimeDescending(key)
}
return a.NewDTimestamp(parser.DTimestamp{Time: t}), rkey, err
case *parser.DTimestampTZ:
var t time.Time
if dir == encoding.Ascending {
rkey, t, err = encoding.DecodeTimeAscending(key)
} else {
rkey, t, err = encoding.DecodeTimeDescending(key)
}
return a.NewDTimestampTZ(parser.DTimestampTZ{Time: t}), rkey, err
case *parser.DInterval:
var d duration.Duration
if dir == encoding.Ascending {
rkey, d, err = encoding.DecodeDurationAscending(key)
} else {
rkey, d, err = encoding.DecodeDurationDescending(key)
}
return a.NewDInterval(parser.DInterval{Duration: d}), rkey, err
default:
return nil, nil, util.Errorf("TODO(pmattis): decoded index key: %s", valType.Type())
}
}
func decodeTableKey(valType parser.Datum, key []byte, dir encoding.Direction) (
parser.Datum, []byte, error) {
if (dir != encoding.Ascending) && (dir != encoding.Descending) {
return nil, nil, util.Errorf("invalid direction: %d", dir)
}
var isNull bool
if key, isNull = encoding.DecodeIfNull(key); isNull {
return parser.DNull, key, nil
}
var rkey []byte
var err error
switch valType.(type) {
case parser.DBool:
var i int64
if dir == encoding.Ascending {
rkey, i, err = encoding.DecodeVarintAscending(key)
} else {
rkey, i, err = encoding.DecodeVarintDescending(key)
}
return parser.DBool(i != 0), rkey, err
case parser.DInt:
var i int64
if dir == encoding.Ascending {
rkey, i, err = encoding.DecodeVarintAscending(key)
} else {
rkey, i, err = encoding.DecodeVarintDescending(key)
}
return parser.DInt(i), rkey, err
case parser.DFloat:
var f float64
if dir == encoding.Ascending {
rkey, f, err = encoding.DecodeFloatAscending(key, nil)
} else {
rkey, f, err = encoding.DecodeFloatDescending(key, nil)
}
return parser.DFloat(f), rkey, err
case *parser.DDecimal:
var d *inf.Dec
if dir == encoding.Ascending {
rkey, d, err = encoding.DecodeDecimalAscending(key, nil)
} else {
rkey, d, err = encoding.DecodeDecimalDescending(key, nil)
}
dd := &parser.DDecimal{}
dd.Set(d)
return dd, rkey, err
case parser.DString:
var r string
if dir == encoding.Ascending {
rkey, r, err = encoding.DecodeStringAscending(key, nil)
} else {
rkey, r, err = encoding.DecodeStringDescending(key, nil)
}
return parser.DString(r), rkey, err
case parser.DBytes:
var r []byte
if dir == encoding.Ascending {
rkey, r, err = encoding.DecodeBytesAscending(key, nil)
} else {
rkey, r, err = encoding.DecodeBytesDescending(key, nil)
}
return parser.DBytes(r), rkey, err
case parser.DDate:
var t int64
if dir == encoding.Ascending {
rkey, t, err = encoding.DecodeVarintAscending(key)
} else {
rkey, t, err = encoding.DecodeVarintDescending(key)
}
return parser.DDate(t), rkey, err
case parser.DTimestamp:
var t time.Time
if dir == encoding.Ascending {
rkey, t, err = encoding.DecodeTimeAscending(key)
} else {
rkey, t, err = encoding.DecodeTimeDescending(key)
}
return parser.DTimestamp{Time: t}, rkey, err
case parser.DInterval:
var d int64
if dir == encoding.Ascending {
rkey, d, err = encoding.DecodeVarintAscending(key)
} else {
rkey, d, err = encoding.DecodeVarintDescending(key)
}
return parser.DInterval{Duration: time.Duration(d)}, rkey, err
default:
return nil, nil, util.Errorf("TODO(pmattis): decoded index key: %s", valType.Type())
}
}