Influxdata
/
influxdb
mirror of https://github.com/influxdata/influxdb.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Rename time batch decoders

pull/10300/head
Edd Robinson 2018-09-05 11:45:15 +01:00
parent c1d82fccf0
commit 9ecadd1a9c
3 changed files with 43 additions and 43 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
tsdb/engine/tsm1/array_encoding.go
View File

@ -19,7 +19,7 @@ func DecodeBooleanArrayBlock(block []byte, a *tsdb.BooleanArray) error {
return err return err
} }
a.Timestamps, err = TimeBatchDecodeAll(tb, a.Timestamps) a.Timestamps, err = TimeArrayDecodeAll(tb, a.Timestamps)
if err != nil { if err != nil {
return err return err
} }
@ -40,7 +40,7 @@ func DecodeFloatArrayBlock(block []byte, a *tsdb.FloatArray) error {
return err return err
} }
a.Timestamps, err = TimeBatchDecodeAll(tb, a.Timestamps) a.Timestamps, err = TimeArrayDecodeAll(tb, a.Timestamps)
if err != nil { if err != nil {
return err return err
} }
@ -61,7 +61,7 @@ func DecodeIntegerArrayBlock(block []byte, a *tsdb.IntegerArray) error {
return err return err
} }
a.Timestamps, err = TimeBatchDecodeAll(tb, a.Timestamps) a.Timestamps, err = TimeArrayDecodeAll(tb, a.Timestamps)
if err != nil { if err != nil {
return err return err
} }
@ -82,7 +82,7 @@ func DecodeUnsignedArrayBlock(block []byte, a *tsdb.UnsignedArray) error {
return err return err
} }
a.Timestamps, err = TimeBatchDecodeAll(tb, a.Timestamps) a.Timestamps, err = TimeArrayDecodeAll(tb, a.Timestamps)
if err != nil { if err != nil {
return err return err
} }
@ -103,7 +103,7 @@ func DecodeStringArrayBlock(block []byte, a *tsdb.StringArray) error {
return err return err
} }
a.Timestamps, err = TimeBatchDecodeAll(tb, a.Timestamps) a.Timestamps, err = TimeArrayDecodeAll(tb, a.Timestamps)
if err != nil { if err != nil {
return err return err
} }

12
tsdb/engine/tsm1/batch_timestamp.go
View File

@ -18,7 +18,7 @@ var (
} }
) )
func TimeBatchDecodeAll(b []byte, dst []int64) ([]int64, error) { func TimeArrayDecodeAll(b []byte, dst []int64) ([]int64, error) {
if len(b) == 0 { if len(b) == 0 {
return []int64{}, nil return []int64{}, nil
} }
@ -34,7 +34,7 @@ func TimeBatchDecodeAll(b []byte, dst []int64) ([]int64, error) {
func timeBatchDecodeAllUncompressed(b []byte, dst []int64) ([]int64, error) { func timeBatchDecodeAllUncompressed(b []byte, dst []int64) ([]int64, error) {
b = b[1:] b = b[1:]
if len(b)&0x7 != 0 { if len(b)&0x7 != 0 {
return []int64{}, fmt.Errorf("TimeBatchDecodeAll: expected multiple of 8 bytes") return []int64{}, fmt.Errorf("TimeArrayDecodeAll: expected multiple of 8 bytes")
} }
count := len(b) / 8 count := len(b) / 8
@ -55,7 +55,7 @@ func timeBatchDecodeAllUncompressed(b []byte, dst []int64) ([]int64, error) {
func timeBatchDecodeAllSimple(b []byte, dst []int64) ([]int64, error) { func timeBatchDecodeAllSimple(b []byte, dst []int64) ([]int64, error) {
if len(b) < 9 { if len(b) < 9 {
return []int64{}, fmt.Errorf("TimeBatchDecodeAll: not enough data to decode packed timestamps") return []int64{}, fmt.Errorf("TimeArrayDecodeAll: not enough data to decode packed timestamps")
} }
div := uint64(math.Pow10(int(b[0] & 0xF))) // multiplier div := uint64(math.Pow10(int(b[0] & 0xF))) // multiplier
@ -82,7 +82,7 @@ func timeBatchDecodeAllSimple(b []byte, dst []int64) ([]int64, error) {
return []int64{}, err return []int64{}, err
} }
if n != count-1 { if n != count-1 {
return []int64{}, fmt.Errorf("TimeBatchDecodeAll: unexpected number of values decoded; got=%d, exp=%d", n, count-1) return []int64{}, fmt.Errorf("TimeArrayDecodeAll: unexpected number of values decoded; got=%d, exp=%d", n, count-1)
} }
// Compute the prefix sum and scale the deltas back up // Compute the prefix sum and scale the deltas back up
@ -105,7 +105,7 @@ func timeBatchDecodeAllSimple(b []byte, dst []int64) ([]int64, error) {
func timeBatchDecodeAllRLE(b []byte, dst []int64) ([]int64, error) { func timeBatchDecodeAllRLE(b []byte, dst []int64) ([]int64, error) {
if len(b) < 9 { if len(b) < 9 {
return []int64{}, fmt.Errorf("TimeBatchDecodeAll: not enough data to decode RLE starting value") return []int64{}, fmt.Errorf("TimeArrayDecodeAll: not enough data to decode RLE starting value")
} }
var k, n int var k, n int
@ -121,7 +121,7 @@ func timeBatchDecodeAllRLE(b []byte, dst []int64) ([]int64, error) {
// Next 1-10 bytes is our (scaled down by factor of 10) run length delta // Next 1-10 bytes is our (scaled down by factor of 10) run length delta
delta, n := binary.Uvarint(b[k:]) delta, n := binary.Uvarint(b[k:])
if n <= 0 { if n <= 0 {
return []int64{}, fmt.Errorf("TimeBatchDecodeAll: invalid run length in decodeRLE") return []int64{}, fmt.Errorf("TimeArrayDecodeAll: invalid run length in decodeRLE")
} }
k += n k += n

64
tsdb/engine/tsm1/batch_timestamp_test.go
View File

@ -10,14 +10,14 @@ import (
"github.com/google/go-cmp/cmp" "github.com/google/go-cmp/cmp"
) )
func TestTimeBatchDecodeAll_NoValues(t *testing.T) { func TestTimeArrayDecodeAll_NoValues(t *testing.T) {
enc := NewTimeEncoder(0) enc := NewTimeEncoder(0)
b, err := enc.Bytes() b, err := enc.Bytes()
if err != nil { if err != nil {
t.Fatalf("unexpected error: %v", err) t.Fatalf("unexpected error: %v", err)
} }
got, err := TimeBatchDecodeAll(b, nil) got, err := TimeArrayDecodeAll(b, nil)
if err != nil { if err != nil {
t.Fatalf("unexpected decode error %q", err) t.Fatalf("unexpected decode error %q", err)
} }
@ -28,7 +28,7 @@ func TestTimeBatchDecodeAll_NoValues(t *testing.T) {
} }
} }
func TestTimeBatchDecodeAll_One(t *testing.T) { func TestTimeArrayDecodeAll_One(t *testing.T) {
enc := NewTimeEncoder(1) enc := NewTimeEncoder(1)
exp := []int64{0} exp := []int64{0}
for _, v := range exp { for _, v := range exp {
@ -43,7 +43,7 @@ func TestTimeBatchDecodeAll_One(t *testing.T) {
t.Fatalf("Wrong encoding used: expected uncompressed, got %v", got) t.Fatalf("Wrong encoding used: expected uncompressed, got %v", got)
} }
got, err := TimeBatchDecodeAll(b, nil) got, err := TimeArrayDecodeAll(b, nil)
if err != nil { if err != nil {
t.Fatalf("unexpected decode error %q", err) t.Fatalf("unexpected decode error %q", err)
} }
@ -53,7 +53,7 @@ func TestTimeBatchDecodeAll_One(t *testing.T) {
} }
} }
func TestTimeBatchDecodeAll_Two(t *testing.T) { func TestTimeArrayDecodeAll_Two(t *testing.T) {
enc := NewTimeEncoder(2) enc := NewTimeEncoder(2)
exp := []int64{0, 1} exp := []int64{0, 1}
for _, v := range exp { for _, v := range exp {
@ -69,7 +69,7 @@ func TestTimeBatchDecodeAll_Two(t *testing.T) {
t.Fatalf("Wrong encoding used: expected rle, got %v", got) t.Fatalf("Wrong encoding used: expected rle, got %v", got)
} }
got, err := TimeBatchDecodeAll(b, nil) got, err := TimeArrayDecodeAll(b, nil)
if err != nil { if err != nil {
t.Fatalf("unexpected decode error %q", err) t.Fatalf("unexpected decode error %q", err)
} }
@ -79,7 +79,7 @@ func TestTimeBatchDecodeAll_Two(t *testing.T) {
} }
} }
func TestTimeBatchDecodeAll_Three(t *testing.T) { func TestTimeArrayDecodeAll_Three(t *testing.T) {
enc := NewTimeEncoder(3) enc := NewTimeEncoder(3)
exp := []int64{0, 1, 3} exp := []int64{0, 1, 3}
for _, v := range exp { for _, v := range exp {
@ -95,7 +95,7 @@ func TestTimeBatchDecodeAll_Three(t *testing.T) {
t.Fatalf("Wrong encoding used: expected rle, got %v", got) t.Fatalf("Wrong encoding used: expected rle, got %v", got)
} }
got, err := TimeBatchDecodeAll(b, nil) got, err := TimeArrayDecodeAll(b, nil)
if err != nil { if err != nil {
t.Fatalf("unexpected decode error %q", err) t.Fatalf("unexpected decode error %q", err)
} }
@ -105,7 +105,7 @@ func TestTimeBatchDecodeAll_Three(t *testing.T) {
} }
} }
func TestTimeBatchDecodeAll_Large_Range(t *testing.T) { func TestTimeArrayDecodeAll_Large_Range(t *testing.T) {
enc := NewTimeEncoder(2) enc := NewTimeEncoder(2)
exp := []int64{1442369134000000000, 1442369135000000000} exp := []int64{1442369134000000000, 1442369135000000000}
for _, v := range exp { for _, v := range exp {
@ -120,7 +120,7 @@ func TestTimeBatchDecodeAll_Large_Range(t *testing.T) {
t.Fatalf("Wrong encoding used: expected rle, got %v", got) t.Fatalf("Wrong encoding used: expected rle, got %v", got)
} }
got, err := TimeBatchDecodeAll(b, nil) got, err := TimeArrayDecodeAll(b, nil)
if err != nil { if err != nil {
t.Fatalf("unexpected decode error %q", err) t.Fatalf("unexpected decode error %q", err)
} }
@ -130,7 +130,7 @@ func TestTimeBatchDecodeAll_Large_Range(t *testing.T) {
} }
} }
func TestTimeBatchDecodeAll_Uncompressed(t *testing.T) { func TestTimeArrayDecodeAll_Uncompressed(t *testing.T) {
enc := NewTimeEncoder(3) enc := NewTimeEncoder(3)
exp := []int64{ exp := []int64{
time.Unix(0, 0).UnixNano(), time.Unix(0, 0).UnixNano(),
@ -156,7 +156,7 @@ func TestTimeBatchDecodeAll_Uncompressed(t *testing.T) {
t.Fatalf("Wrong encoding used: expected uncompressed, got %v", got) t.Fatalf("Wrong encoding used: expected uncompressed, got %v", got)
} }
got, err := TimeBatchDecodeAll(b, nil) got, err := TimeArrayDecodeAll(b, nil)
if err != nil { if err != nil {
t.Fatalf("unexpected decode error %q", err) t.Fatalf("unexpected decode error %q", err)
} }
@ -166,7 +166,7 @@ func TestTimeBatchDecodeAll_Uncompressed(t *testing.T) {
} }
} }
func TestTimeBatchDecodeAll_RLE(t *testing.T) { func TestTimeArrayDecodeAll_RLE(t *testing.T) {
enc := NewTimeEncoder(512) enc := NewTimeEncoder(512)
var exp []int64 var exp []int64
for i := 0; i < 500; i++ { for i := 0; i < 500; i++ {
@ -190,7 +190,7 @@ func TestTimeBatchDecodeAll_RLE(t *testing.T) {
t.Fatalf("unexpected error: %v", err) t.Fatalf("unexpected error: %v", err)
} }
got, err := TimeBatchDecodeAll(b, nil) got, err := TimeArrayDecodeAll(b, nil)
if err != nil { if err != nil {
t.Fatalf("unexpected decode error %q", err) t.Fatalf("unexpected decode error %q", err)
} }
@ -200,7 +200,7 @@ func TestTimeBatchDecodeAll_RLE(t *testing.T) {
} }
} }
func TestTimeBatchDecodeAll_Reverse(t *testing.T) { func TestTimeArrayDecodeAll_Reverse(t *testing.T) {
enc := NewTimeEncoder(3) enc := NewTimeEncoder(3)
exp := []int64{ exp := []int64{
int64(3), int64(3),
@ -221,7 +221,7 @@ func TestTimeBatchDecodeAll_Reverse(t *testing.T) {
t.Fatalf("Wrong encoding used: expected uncompressed, got %v", got) t.Fatalf("Wrong encoding used: expected uncompressed, got %v", got)
} }
got, err := TimeBatchDecodeAll(b, nil) got, err := TimeArrayDecodeAll(b, nil)
if err != nil { if err != nil {
t.Fatalf("unexpected decode error %q", err) t.Fatalf("unexpected decode error %q", err)
} }
@ -231,7 +231,7 @@ func TestTimeBatchDecodeAll_Reverse(t *testing.T) {
} }
} }
func TestTimeBatchDecodeAll_Negative(t *testing.T) { func TestTimeArrayDecodeAll_Negative(t *testing.T) {
enc := NewTimeEncoder(3) enc := NewTimeEncoder(3)
exp := []int64{ exp := []int64{
-2352281900722994752, 1438442655375607923, -4110452567888190110, -2352281900722994752, 1438442655375607923, -4110452567888190110,
@ -257,7 +257,7 @@ func TestTimeBatchDecodeAll_Negative(t *testing.T) {
t.Fatalf("Wrong encoding used: expected uncompressed, got %v", got) t.Fatalf("Wrong encoding used: expected uncompressed, got %v", got)
} }
got, err := TimeBatchDecodeAll(b, nil) got, err := TimeArrayDecodeAll(b, nil)
if err != nil { if err != nil {
t.Fatalf("unexpected decode error %q", err) t.Fatalf("unexpected decode error %q", err)
} }
@ -267,7 +267,7 @@ func TestTimeBatchDecodeAll_Negative(t *testing.T) {
} }
} }
func TestTimeBatchDecodeAll_220SecondDelta(t *testing.T) { func TestTimeArrayDecodeAll_220SecondDelta(t *testing.T) {
enc := NewTimeEncoder(256) enc := NewTimeEncoder(256)
var exp []int64 var exp []int64
now := time.Now() now := time.Now()
@ -293,7 +293,7 @@ func TestTimeBatchDecodeAll_220SecondDelta(t *testing.T) {
t.Fatalf("Wrong encoding used: expected uncompressed, got %v", got) t.Fatalf("Wrong encoding used: expected uncompressed, got %v", got)
} }
got, err := TimeBatchDecodeAll(b, nil) got, err := TimeArrayDecodeAll(b, nil)
if err != nil { if err != nil {
t.Fatalf("unexpected decode error %q", err) t.Fatalf("unexpected decode error %q", err)
} }
@ -303,7 +303,7 @@ func TestTimeBatchDecodeAll_220SecondDelta(t *testing.T) {
} }
} }
func TestTimeBatchDecodeAll_Quick(t *testing.T) { func TestTimeArrayDecodeAll_Quick(t *testing.T) {
quick.Check(func(values []int64) bool { quick.Check(func(values []int64) bool {
// Write values to encoder. // Write values to encoder.
enc := NewTimeEncoder(1024) enc := NewTimeEncoder(1024)
@ -319,7 +319,7 @@ func TestTimeBatchDecodeAll_Quick(t *testing.T) {
t.Fatal(err) t.Fatal(err)
} }
got, err := TimeBatchDecodeAll(buf, nil) got, err := TimeArrayDecodeAll(buf, nil)
if err != nil { if err != nil {
t.Fatalf("unexpected decode error %q", err) t.Fatalf("unexpected decode error %q", err)
} }
@ -332,7 +332,7 @@ func TestTimeBatchDecodeAll_Quick(t *testing.T) {
}, nil) }, nil)
} }
func TestTimeBatchDecodeAll_RLESeconds(t *testing.T) { func TestTimeArrayDecodeAll_RLESeconds(t *testing.T) {
enc := NewTimeEncoder(6) enc := NewTimeEncoder(6)
exp := make([]int64, 6) exp := make([]int64, 6)
@ -356,7 +356,7 @@ func TestTimeBatchDecodeAll_RLESeconds(t *testing.T) {
t.Fatalf("unexpected error: %v", err) t.Fatalf("unexpected error: %v", err)
} }
got, err := TimeBatchDecodeAll(b, nil) got, err := TimeArrayDecodeAll(b, nil)
if err != nil { if err != nil {
t.Fatalf("unexpected decode error %q", err) t.Fatalf("unexpected decode error %q", err)
} }
@ -366,7 +366,7 @@ func TestTimeBatchDecodeAll_RLESeconds(t *testing.T) {
} }
} }
func TestTimeBatchDecodeAll_Corrupt(t *testing.T) { func TestTimeArrayDecodeAll_Corrupt(t *testing.T) {
cases := []string{ cases := []string{
"\x10\x14", // Packed: not enough data "\x10\x14", // Packed: not enough data
"\x20\x00", // RLE: not enough data for starting timestamp "\x20\x00", // RLE: not enough data for starting timestamp
@ -377,7 +377,7 @@ func TestTimeBatchDecodeAll_Corrupt(t *testing.T) {
for _, c := range cases { for _, c := range cases {
t.Run(fmt.Sprintf("%q", c), func(t *testing.T) { t.Run(fmt.Sprintf("%q", c), func(t *testing.T) {
got, err := TimeBatchDecodeAll([]byte(c), nil) got, err := TimeArrayDecodeAll([]byte(c), nil)
if err == nil { if err == nil {
t.Fatal("exp an err, got nil") t.Fatal("exp an err, got nil")
} }
@ -390,7 +390,7 @@ func TestTimeBatchDecodeAll_Corrupt(t *testing.T) {
} }
} }
func BenchmarkTimeBatchDecodeAllUncompressed(b *testing.B) { func BenchmarkTimeArrayDecodeAllUncompressed(b *testing.B) {
benchmarks := []int{ benchmarks := []int{
5, 5,
55, 55,
@ -424,13 +424,13 @@ func BenchmarkTimeBatchDecodeAllUncompressed(b *testing.B) {
dst := make([]int64, size) dst := make([]int64, size)
for i := 0; i < b.N; i++ { for i := 0; i < b.N; i++ {
dst, _ = TimeBatchDecodeAll(bytes, dst) dst, _ = TimeArrayDecodeAll(bytes, dst)
} }
}) })
} }
} }
func BenchmarkTimeBatchDecodeAllPackedSimple(b *testing.B) { func BenchmarkTimeArrayDecodeAllPackedSimple(b *testing.B) {
benchmarks := []int{ benchmarks := []int{
5, 5,
55, 55,
@ -453,13 +453,13 @@ func BenchmarkTimeBatchDecodeAllPackedSimple(b *testing.B) {
dst := make([]int64, size) dst := make([]int64, size)
for i := 0; i < b.N; i++ { for i := 0; i < b.N; i++ {
dst, _ = TimeBatchDecodeAll(bytes, dst) dst, _ = TimeArrayDecodeAll(bytes, dst)
} }
}) })
} }
} }
func BenchmarkTimeBatchDecodeAllRLE(b *testing.B) { func BenchmarkTimeArrayDecodeAllRLE(b *testing.B) {
benchmarks := []struct { benchmarks := []struct {
n int n int
delta int64 delta int64
@ -484,7 +484,7 @@ func BenchmarkTimeBatchDecodeAllRLE(b *testing.B) {
dst := make([]int64, bm.n) dst := make([]int64, bm.n)
for i := 0; i < b.N; i++ { for i := 0; i < b.N; i++ {
dst, _ = TimeBatchDecodeAll(bytes, dst) dst, _ = TimeArrayDecodeAll(bytes, dst)
} }
}) })
} }