107 lines
3.4 KiB
Go
107 lines
3.4 KiB
Go
package tsdb
|
|
|
|
import (
|
|
"encoding/binary"
|
|
|
|
"github.com/influxdata/influxdb/v2"
|
|
"github.com/influxdata/influxdb/v2/models"
|
|
)
|
|
|
|
// DecodeName converts tsdb internal serialization back to organization and bucket IDs.
|
|
func DecodeName(name [16]byte) (org, bucket influxdb.ID) {
|
|
org = influxdb.ID(binary.BigEndian.Uint64(name[0:8]))
|
|
bucket = influxdb.ID(binary.BigEndian.Uint64(name[8:16]))
|
|
return
|
|
}
|
|
|
|
// DecodeNameSlice converts tsdb internal serialization back to organization and bucket IDs.
|
|
func DecodeNameSlice(name []byte) (org, bucket influxdb.ID) {
|
|
return influxdb.ID(binary.BigEndian.Uint64(name[0:8])), influxdb.ID(binary.BigEndian.Uint64(name[8:16]))
|
|
}
|
|
|
|
// EncodeName converts org/bucket pairs to the tsdb internal serialization
|
|
func EncodeName(org, bucket influxdb.ID) [16]byte {
|
|
var nameBytes [16]byte
|
|
binary.BigEndian.PutUint64(nameBytes[0:8], uint64(org))
|
|
binary.BigEndian.PutUint64(nameBytes[8:16], uint64(bucket))
|
|
return nameBytes
|
|
}
|
|
|
|
// EncodeNameSlice converts org/bucket pairs to the tsdb internal serialization but returns a byte slice.
|
|
func EncodeNameSlice(org, bucket influxdb.ID) []byte {
|
|
buf := EncodeName(org, bucket)
|
|
return buf[:]
|
|
}
|
|
|
|
// EncodeOrgName converts org to the tsdb internal serialization that may be used
|
|
// as a prefix when searching for keys matching a specific organization.
|
|
func EncodeOrgName(org influxdb.ID) [8]byte {
|
|
var orgBytes [8]byte
|
|
binary.BigEndian.PutUint64(orgBytes[0:8], uint64(org))
|
|
return orgBytes
|
|
}
|
|
|
|
// EncodeNameString converts org/bucket pairs to the tsdb internal serialization
|
|
func EncodeNameString(org, bucket influxdb.ID) string {
|
|
name := EncodeName(org, bucket)
|
|
return string(name[:])
|
|
}
|
|
|
|
// ExplodePoints creates a list of points that only contains one field per point. It also
|
|
// moves the measurement to a tag, and changes the measurement to be the provided argument.
|
|
func ExplodePoints(org, bucket influxdb.ID, points []models.Point) ([]models.Point, error) {
|
|
out := make([]models.Point, 0, len(points))
|
|
|
|
// TODO(jeff): We should add a RawEncode() method or something to the influxdb.ID type
|
|
// or we should use hex encoded measurement names. Either way, we shouldn't be doing a
|
|
// decode of the encode here, and we don't want to depend on details of how the ID type
|
|
// is represented.
|
|
ob := EncodeName(org, bucket)
|
|
name := string(ob[:])
|
|
|
|
tags := make(models.Tags, 1)
|
|
for _, pt := range points {
|
|
tags = tags[:1] // reset buffer for next point.
|
|
|
|
tags[0] = models.NewTag(models.MeasurementTagKeyBytes, pt.Name())
|
|
pt.ForEachTag(func(k, v []byte) bool {
|
|
tags = append(tags, models.NewTag(k, v))
|
|
return true
|
|
})
|
|
|
|
t := pt.Time()
|
|
itr := pt.FieldIterator()
|
|
tags = append(tags, models.Tag{}) // Make room for field key and value.
|
|
|
|
for itr.Next() {
|
|
tags[len(tags)-1] = models.NewTag(models.FieldKeyTagKeyBytes, itr.FieldKey())
|
|
|
|
var err error
|
|
field := make(models.Fields, 1)
|
|
switch itr.Type() {
|
|
case models.Float:
|
|
field[string(itr.FieldKey())], err = itr.FloatValue()
|
|
case models.Integer:
|
|
field[string(itr.FieldKey())], err = itr.IntegerValue()
|
|
case models.Boolean:
|
|
field[string(itr.FieldKey())], err = itr.BooleanValue()
|
|
case models.String:
|
|
field[string(itr.FieldKey())] = itr.StringValue()
|
|
case models.Unsigned:
|
|
field[string(itr.FieldKey())], err = itr.UnsignedValue()
|
|
}
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
pt, err := models.NewPoint(name, tags, field, t)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, pt)
|
|
}
|
|
}
|
|
|
|
return out, nil
|
|
}
|