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

394 lines
15 KiB
Go
Raw Normal View History

refactor query engine
2015-11-04 21:06:06 +00:00
package influxql_test
import (
"math/rand"
"testing"
"time"
"github.com/davecgh/go-spew/spew"
rename influxdb/influxdb to influxdata/influxdb This commit changes all the import and URL references from: github.com/influxdb/influxdb to: github.com/influxdata/influxdb
2016-02-10 17:26:18 +00:00
"github.com/influxdata/influxdb/influxql"
"github.com/influxdata/influxdb/pkg/deep"
refactor query engine
2015-11-04 21:06:06 +00:00
)
Fixed a bug in first() and last() where the time was lost last() would always return the last output of the iterator (which isn't necessarily the last time value due to how the merge iterator works) and first() would always return the first output of the iterator (wrong for the same reason). Now the time is kept by the reduce function and the times are wiped as part of the reduce iterator after the value has been found.
2016-01-23 03:04:10 +00:00
// Ensure that a float iterator can be created for a count() call.
refactor query engine
2015-11-04 21:06:06 +00:00
func TestCallIterator_Count_Float(t *testing.T) {
itr := influxql.NewCallIterator(
&FloatIterator{Points: []influxql.FloatPoint{
Fix reduce iterators to separate by name Previously reduce iterators just separated points by tags. If you had identical tags but different names, it would group those together so you could have these two points: cpu value=1 mem value=2 When you performed a `mean(value)` call and included both cpu and mem as sources, it would return one mem series with a value of 1.5 instead of two serieses.
2016-02-03 21:56:15 +00:00
{Name: "cpu", Time: 0, Value: 15, Tags: ParseTags("region=us-east,host=hostA")},
{Name: "cpu", Time: 1, Value: 11, Tags: ParseTags("region=us-west,host=hostB")},
{Name: "cpu", Time: 2, Value: 10, Tags: ParseTags("region=us-east,host=hostA")},
{Name: "cpu", Time: 1, Value: 10, Tags: ParseTags("region=us-west,host=hostA")},
refactor query engine
2015-11-04 21:06:06 +00:00
Fix reduce iterators to separate by name Previously reduce iterators just separated points by tags. If you had identical tags but different names, it would group those together so you could have these two points: cpu value=1 mem value=2 When you performed a `mean(value)` call and included both cpu and mem as sources, it would return one mem series with a value of 1.5 instead of two serieses.
2016-02-03 21:56:15 +00:00
{Name: "cpu", Time: 5, Value: 20, Tags: ParseTags("region=us-east,host=hostA")},
refactor query engine
2015-11-04 21:06:06 +00:00
Fix reduce iterators to separate by name Previously reduce iterators just separated points by tags. If you had identical tags but different names, it would group those together so you could have these two points: cpu value=1 mem value=2 When you performed a `mean(value)` call and included both cpu and mem as sources, it would return one mem series with a value of 1.5 instead of two serieses.
2016-02-03 21:56:15 +00:00
{Name: "cpu", Time: 23, Value: 8, Tags: ParseTags("region=us-west,host=hostB")},
{Name: "mem", Time: 23, Value: 10, Tags: ParseTags("region=us-west,host=hostB")},
refactor query engine
2015-11-04 21:06:06 +00:00
}},
influxql.IteratorOptions{
Expr: MustParseExpr(`count("value")`),
Dimensions: []string{"host"},
Interval: influxql.Interval{Duration: 5 * time.Nanosecond},
},
)
Fix reduce iterators to separate by name Previously reduce iterators just separated points by tags. If you had identical tags but different names, it would group those together so you could have these two points: cpu value=1 mem value=2 When you performed a `mean(value)` call and included both cpu and mem as sources, it would return one mem series with a value of 1.5 instead of two serieses.
2016-02-03 21:56:15 +00:00
if a := Iterators([]influxql.Iterator{itr}).ReadAll(); !deep.Equal(a, [][]influxql.Point{
{&influxql.FloatPoint{Name: "cpu", Time: 0, Value: 3, Tags: ParseTags("host=hostA")}},
{&influxql.FloatPoint{Name: "cpu", Time: 0, Value: 1, Tags: ParseTags("host=hostB")}},
{&influxql.FloatPoint{Name: "cpu", Time: 5, Value: 1, Tags: ParseTags("host=hostA")}},
{&influxql.FloatPoint{Name: "cpu", Time: 20, Value: 1, Tags: ParseTags("host=hostB")}},
{&influxql.FloatPoint{Name: "mem", Time: 20, Value: 1, Tags: ParseTags("host=hostB")}},
}) {
Fixed a bug in first() and last() where the time was lost last() would always return the last output of the iterator (which isn't necessarily the last time value due to how the merge iterator works) and first() would always return the first output of the iterator (wrong for the same reason). Now the time is kept by the reduce function and the times are wiped as part of the reduce iterator after the value has been found.
2016-01-23 03:04:10 +00:00
t.Fatalf("unexpected points: %s", spew.Sdump(a))
}
}
// Ensure that an integer iterator can be created for a count() call.
func TestCallIterator_Count_Integer(t *testing.T) {
itr := influxql.NewCallIterator(
&IntegerIterator{Points: []influxql.IntegerPoint{
Fix reduce iterators to separate by name Previously reduce iterators just separated points by tags. If you had identical tags but different names, it would group those together so you could have these two points: cpu value=1 mem value=2 When you performed a `mean(value)` call and included both cpu and mem as sources, it would return one mem series with a value of 1.5 instead of two serieses.
2016-02-03 21:56:15 +00:00
{Name: "cpu", Time: 0, Value: 15, Tags: ParseTags("region=us-east,host=hostA")},
{Name: "cpu", Time: 1, Value: 11, Tags: ParseTags("region=us-west,host=hostB")},
{Name: "cpu", Time: 2, Value: 10, Tags: ParseTags("region=us-east,host=hostA")},
{Name: "cpu", Time: 1, Value: 10, Tags: ParseTags("region=us-west,host=hostA")},
Fixed a bug in first() and last() where the time was lost last() would always return the last output of the iterator (which isn't necessarily the last time value due to how the merge iterator works) and first() would always return the first output of the iterator (wrong for the same reason). Now the time is kept by the reduce function and the times are wiped as part of the reduce iterator after the value has been found.
2016-01-23 03:04:10 +00:00
Fix reduce iterators to separate by name Previously reduce iterators just separated points by tags. If you had identical tags but different names, it would group those together so you could have these two points: cpu value=1 mem value=2 When you performed a `mean(value)` call and included both cpu and mem as sources, it would return one mem series with a value of 1.5 instead of two serieses.
2016-02-03 21:56:15 +00:00
{Name: "cpu", Time: 5, Value: 20, Tags: ParseTags("region=us-east,host=hostA")},
Fixed a bug in first() and last() where the time was lost last() would always return the last output of the iterator (which isn't necessarily the last time value due to how the merge iterator works) and first() would always return the first output of the iterator (wrong for the same reason). Now the time is kept by the reduce function and the times are wiped as part of the reduce iterator after the value has been found.
2016-01-23 03:04:10 +00:00
Fix reduce iterators to separate by name Previously reduce iterators just separated points by tags. If you had identical tags but different names, it would group those together so you could have these two points: cpu value=1 mem value=2 When you performed a `mean(value)` call and included both cpu and mem as sources, it would return one mem series with a value of 1.5 instead of two serieses.
2016-02-03 21:56:15 +00:00
{Name: "cpu", Time: 23, Value: 8, Tags: ParseTags("region=us-west,host=hostB")},
{Name: "mem", Time: 23, Value: 10, Tags: ParseTags("region=us-west,host=hostB")},
Fixed a bug in first() and last() where the time was lost last() would always return the last output of the iterator (which isn't necessarily the last time value due to how the merge iterator works) and first() would always return the first output of the iterator (wrong for the same reason). Now the time is kept by the reduce function and the times are wiped as part of the reduce iterator after the value has been found.
2016-01-23 03:04:10 +00:00
}},
influxql.IteratorOptions{
Expr: MustParseExpr(`count("value")`),
Dimensions: []string{"host"},
Interval: influxql.Interval{Duration: 5 * time.Nanosecond},
},
)
Fix reduce iterators to separate by name Previously reduce iterators just separated points by tags. If you had identical tags but different names, it would group those together so you could have these two points: cpu value=1 mem value=2 When you performed a `mean(value)` call and included both cpu and mem as sources, it would return one mem series with a value of 1.5 instead of two serieses.
2016-02-03 21:56:15 +00:00
if a := Iterators([]influxql.Iterator{itr}).ReadAll(); !deep.Equal(a, [][]influxql.Point{
{&influxql.IntegerPoint{Name: "cpu", Time: 0, Value: 3, Tags: ParseTags("host=hostA")}},
{&influxql.IntegerPoint{Name: "cpu", Time: 0, Value: 1, Tags: ParseTags("host=hostB")}},
{&influxql.IntegerPoint{Name: "cpu", Time: 5, Value: 1, Tags: ParseTags("host=hostA")}},
{&influxql.IntegerPoint{Name: "cpu", Time: 20, Value: 1, Tags: ParseTags("host=hostB")}},
{&influxql.IntegerPoint{Name: "mem", Time: 20, Value: 1, Tags: ParseTags("host=hostB")}},
}) {
refactor query engine
2015-11-04 21:06:06 +00:00
t.Fatalf("unexpected points: %s", spew.Sdump(a))
}
}
// Ensure that a float iterator can be created for a min() call.
func TestCallIterator_Min_Float(t *testing.T) {
itr := influxql.NewCallIterator(
&FloatIterator{Points: []influxql.FloatPoint{
{Time: 0, Value: 15, Tags: ParseTags("region=us-east,host=hostA")},
{Time: 1, Value: 11, Tags: ParseTags("region=us-west,host=hostB")},
{Time: 2, Value: 10, Tags: ParseTags("region=us-east,host=hostA")},
Fixed a bug in first() and last() where the time was lost last() would always return the last output of the iterator (which isn't necessarily the last time value due to how the merge iterator works) and first() would always return the first output of the iterator (wrong for the same reason). Now the time is kept by the reduce function and the times are wiped as part of the reduce iterator after the value has been found.
2016-01-23 03:04:10 +00:00
{Time: 4, Value: 12, Tags: ParseTags("region=us-east,host=hostA")},
refactor query engine
2015-11-04 21:06:06 +00:00
{Time: 1, Value: 10, Tags: ParseTags("region=us-west,host=hostA")},
{Time: 5, Value: 20, Tags: ParseTags("region=us-east,host=hostA")},
{Time: 23, Value: 8, Tags: ParseTags("region=us-west,host=hostB")},
}},
influxql.IteratorOptions{
Expr: MustParseExpr(`min("value")`),
Dimensions: []string{"host"},
Interval: influxql.Interval{Duration: 5 * time.Nanosecond},
},
)
Fixed a bug in first() and last() where the time was lost last() would always return the last output of the iterator (which isn't necessarily the last time value due to how the merge iterator works) and first() would always return the first output of the iterator (wrong for the same reason). Now the time is kept by the reduce function and the times are wiped as part of the reduce iterator after the value has been found.
2016-01-23 03:04:10 +00:00
if a, ok := CompareFloatIterator(itr, []influxql.FloatPoint{
{Time: 0, Value: 10, Tags: ParseTags("host=hostA")},
{Time: 0, Value: 11, Tags: ParseTags("host=hostB")},
{Time: 5, Value: 20, Tags: ParseTags("host=hostA")},
{Time: 20, Value: 8, Tags: ParseTags("host=hostB")},
}); !ok {
t.Fatalf("unexpected points: %s", spew.Sdump(a))
}
}
// Ensure that a integer iterator can be created for a min() call.
func TestCallIterator_Min_Integer(t *testing.T) {
itr := influxql.NewCallIterator(
&IntegerIterator{Points: []influxql.IntegerPoint{
{Time: 0, Value: 15, Tags: ParseTags("region=us-east,host=hostA")},
{Time: 1, Value: 11, Tags: ParseTags("region=us-west,host=hostB")},
{Time: 2, Value: 10, Tags: ParseTags("region=us-east,host=hostA")},
{Time: 4, Value: 12, Tags: ParseTags("region=us-east,host=hostA")},
{Time: 1, Value: 10, Tags: ParseTags("region=us-west,host=hostA")},
{Time: 5, Value: 20, Tags: ParseTags("region=us-east,host=hostA")},
{Time: 23, Value: 8, Tags: ParseTags("region=us-west,host=hostB")},
}},
influxql.IteratorOptions{
Expr: MustParseExpr(`min("value")`),
Dimensions: []string{"host"},
Interval: influxql.Interval{Duration: 5 * time.Nanosecond},
},
)
if a, ok := CompareIntegerIterator(itr, []influxql.IntegerPoint{
{Time: 0, Value: 10, Tags: ParseTags("host=hostA")},
{Time: 0, Value: 11, Tags: ParseTags("host=hostB")},
{Time: 5, Value: 20, Tags: ParseTags("host=hostA")},
{Time: 20, Value: 8, Tags: ParseTags("host=hostB")},
}); !ok {
refactor query engine
2015-11-04 21:06:06 +00:00
t.Fatalf("unexpected points: %s", spew.Sdump(a))
}
}
// Ensure that a float iterator can be created for a max() call.
func TestCallIterator_Max_Float(t *testing.T) {
itr := influxql.NewCallIterator(
&FloatIterator{Points: []influxql.FloatPoint{
{Time: 0, Value: 15, Tags: ParseTags("region=us-east,host=hostA")},
{Time: 1, Value: 11, Tags: ParseTags("region=us-west,host=hostB")},
{Time: 2, Value: 10, Tags: ParseTags("region=us-east,host=hostA")},
{Time: 1, Value: 10, Tags: ParseTags("region=us-west,host=hostA")},
{Time: 5, Value: 20, Tags: ParseTags("region=us-east,host=hostA")},
{Time: 23, Value: 8, Tags: ParseTags("region=us-west,host=hostB")},
}},
influxql.IteratorOptions{
Expr: MustParseExpr(`max("value")`),
Dimensions: []string{"host"},
Interval: influxql.Interval{Duration: 5 * time.Nanosecond},
},
)
Fixed a bug in first() and last() where the time was lost last() would always return the last output of the iterator (which isn't necessarily the last time value due to how the merge iterator works) and first() would always return the first output of the iterator (wrong for the same reason). Now the time is kept by the reduce function and the times are wiped as part of the reduce iterator after the value has been found.
2016-01-23 03:04:10 +00:00
if a, ok := CompareFloatIterator(itr, []influxql.FloatPoint{
{Time: 0, Value: 15, Tags: ParseTags("host=hostA")},
{Time: 0, Value: 11, Tags: ParseTags("host=hostB")},
{Time: 5, Value: 20, Tags: ParseTags("host=hostA")},
{Time: 20, Value: 8, Tags: ParseTags("host=hostB")},
}); !ok {
t.Fatalf("unexpected points: %s", spew.Sdump(a))
}
}
// Ensure that a integer iterator can be created for a max() call.
func TestCallIterator_Max_Integer(t *testing.T) {
itr := influxql.NewCallIterator(
&IntegerIterator{Points: []influxql.IntegerPoint{
{Time: 0, Value: 15, Tags: ParseTags("region=us-east,host=hostA")},
{Time: 1, Value: 11, Tags: ParseTags("region=us-west,host=hostB")},
{Time: 2, Value: 10, Tags: ParseTags("region=us-east,host=hostA")},
{Time: 1, Value: 10, Tags: ParseTags("region=us-west,host=hostA")},
{Time: 5, Value: 20, Tags: ParseTags("region=us-east,host=hostA")},
{Time: 23, Value: 8, Tags: ParseTags("region=us-west,host=hostB")},
}},
influxql.IteratorOptions{
Expr: MustParseExpr(`max("value")`),
Dimensions: []string{"host"},
Interval: influxql.Interval{Duration: 5 * time.Nanosecond},
},
)
if a, ok := CompareIntegerIterator(itr, []influxql.IntegerPoint{
{Time: 0, Value: 15, Tags: ParseTags("host=hostA")},
{Time: 0, Value: 11, Tags: ParseTags("host=hostB")},
{Time: 5, Value: 20, Tags: ParseTags("host=hostA")},
{Time: 20, Value: 8, Tags: ParseTags("host=hostB")},
}); !ok {
refactor query engine
2015-11-04 21:06:06 +00:00
t.Fatalf("unexpected points: %s", spew.Sdump(a))
}
}
// Ensure that a float iterator can be created for a sum() call.
func TestCallIterator_Sum_Float(t *testing.T) {
itr := influxql.NewCallIterator(
&FloatIterator{Points: []influxql.FloatPoint{
{Time: 0, Value: 15, Tags: ParseTags("region=us-east,host=hostA")},
{Time: 1, Value: 11, Tags: ParseTags("region=us-west,host=hostB")},
{Time: 2, Value: 10, Tags: ParseTags("region=us-east,host=hostA")},
{Time: 1, Value: 10, Tags: ParseTags("region=us-west,host=hostA")},
{Time: 5, Value: 20, Tags: ParseTags("region=us-east,host=hostA")},
{Time: 23, Value: 8, Tags: ParseTags("region=us-west,host=hostB")},
}},
influxql.IteratorOptions{
Expr: MustParseExpr(`sum("value")`),
Dimensions: []string{"host"},
Interval: influxql.Interval{Duration: 5 * time.Nanosecond},
},
)
Fixed a bug in first() and last() where the time was lost last() would always return the last output of the iterator (which isn't necessarily the last time value due to how the merge iterator works) and first() would always return the first output of the iterator (wrong for the same reason). Now the time is kept by the reduce function and the times are wiped as part of the reduce iterator after the value has been found.
2016-01-23 03:04:10 +00:00
if a, ok := CompareFloatIterator(itr, []influxql.FloatPoint{
{Time: 0, Value: 35, Tags: ParseTags("host=hostA")},
{Time: 0, Value: 11, Tags: ParseTags("host=hostB")},
{Time: 5, Value: 20, Tags: ParseTags("host=hostA")},
{Time: 20, Value: 8, Tags: ParseTags("host=hostB")},
}); !ok {
t.Fatalf("unexpected points: %s", spew.Sdump(a))
}
}
// Ensure that an integer iterator can be created for a sum() call.
func TestCallIterator_Sum_Integer(t *testing.T) {
itr := influxql.NewCallIterator(
&IntegerIterator{Points: []influxql.IntegerPoint{
{Time: 0, Value: 15, Tags: ParseTags("region=us-east,host=hostA")},
{Time: 1, Value: 11, Tags: ParseTags("region=us-west,host=hostB")},
{Time: 2, Value: 10, Tags: ParseTags("region=us-east,host=hostA")},
{Time: 1, Value: 10, Tags: ParseTags("region=us-west,host=hostA")},
{Time: 5, Value: 20, Tags: ParseTags("region=us-east,host=hostA")},
{Time: 23, Value: 8, Tags: ParseTags("region=us-west,host=hostB")},
}},
influxql.IteratorOptions{
Expr: MustParseExpr(`sum("value")`),
Dimensions: []string{"host"},
Interval: influxql.Interval{Duration: 5 * time.Nanosecond},
},
)
if a, ok := CompareIntegerIterator(itr, []influxql.IntegerPoint{
{Time: 0, Value: 35, Tags: ParseTags("host=hostA")},
{Time: 0, Value: 11, Tags: ParseTags("host=hostB")},
{Time: 5, Value: 20, Tags: ParseTags("host=hostA")},
{Time: 20, Value: 8, Tags: ParseTags("host=hostB")},
}); !ok {
refactor query engine
2015-11-04 21:06:06 +00:00
t.Fatalf("unexpected points: %s", spew.Sdump(a))
}
}
// Ensure that a float iterator can be created for a first() call.
func TestCallIterator_First_Float(t *testing.T) {
itr := influxql.NewCallIterator(
&FloatIterator{Points: []influxql.FloatPoint{
{Time: 1, Value: 11, Tags: ParseTags("region=us-west,host=hostB")},
{Time: 2, Value: 10, Tags: ParseTags("region=us-east,host=hostA")},
{Time: 0, Value: 15, Tags: ParseTags("region=us-east,host=hostA")},
{Time: 1, Value: 10, Tags: ParseTags("region=us-west,host=hostA")},
{Time: 6, Value: 20, Tags: ParseTags("region=us-east,host=hostA")},
{Time: 23, Value: 8, Tags: ParseTags("region=us-west,host=hostB")},
}},
influxql.IteratorOptions{
Expr: MustParseExpr(`first("value")`),
Dimensions: []string{"host"},
Interval: influxql.Interval{Duration: 5 * time.Nanosecond},
},
)
Fixed a bug in first() and last() where the time was lost last() would always return the last output of the iterator (which isn't necessarily the last time value due to how the merge iterator works) and first() would always return the first output of the iterator (wrong for the same reason). Now the time is kept by the reduce function and the times are wiped as part of the reduce iterator after the value has been found.
2016-01-23 03:04:10 +00:00
if a, ok := CompareFloatIterator(itr, []influxql.FloatPoint{
{Time: 0, Value: 15, Tags: ParseTags("host=hostA")},
{Time: 0, Value: 11, Tags: ParseTags("host=hostB")},
{Time: 5, Value: 20, Tags: ParseTags("host=hostA")},
{Time: 20, Value: 8, Tags: ParseTags("host=hostB")},
}); !ok {
t.Fatalf("unexpected points: %s", spew.Sdump(a))
}
}
// Ensure that an integer iterator can be created for a first() call.
func TestCallIterator_First_Integer(t *testing.T) {
itr := influxql.NewCallIterator(
&IntegerIterator{Points: []influxql.IntegerPoint{
{Time: 1, Value: 11, Tags: ParseTags("region=us-west,host=hostB")},
{Time: 2, Value: 10, Tags: ParseTags("region=us-east,host=hostA")},
{Time: 0, Value: 15, Tags: ParseTags("region=us-east,host=hostA")},
{Time: 1, Value: 10, Tags: ParseTags("region=us-west,host=hostA")},
{Time: 6, Value: 20, Tags: ParseTags("region=us-east,host=hostA")},
{Time: 23, Value: 8, Tags: ParseTags("region=us-west,host=hostB")},
}},
influxql.IteratorOptions{
Expr: MustParseExpr(`first("value")`),
Dimensions: []string{"host"},
Interval: influxql.Interval{Duration: 5 * time.Nanosecond},
},
)
if a, ok := CompareIntegerIterator(itr, []influxql.IntegerPoint{
{Time: 0, Value: 15, Tags: ParseTags("host=hostA")},
{Time: 0, Value: 11, Tags: ParseTags("host=hostB")},
{Time: 5, Value: 20, Tags: ParseTags("host=hostA")},
{Time: 20, Value: 8, Tags: ParseTags("host=hostB")},
}); !ok {
refactor query engine
2015-11-04 21:06:06 +00:00
t.Fatalf("unexpected points: %s", spew.Sdump(a))
}
}
// Ensure that a float iterator can be created for a last() call.
func TestCallIterator_Last_Float(t *testing.T) {
itr := influxql.NewCallIterator(
&FloatIterator{Points: []influxql.FloatPoint{
{Time: 1, Value: 11, Tags: ParseTags("region=us-west,host=hostB")},
{Time: 2, Value: 10, Tags: ParseTags("region=us-east,host=hostA")},
{Time: 0, Value: 15, Tags: ParseTags("region=us-east,host=hostA")},
{Time: 1, Value: 10, Tags: ParseTags("region=us-west,host=hostA")},
{Time: 6, Value: 20, Tags: ParseTags("region=us-east,host=hostA")},
{Time: 23, Value: 8, Tags: ParseTags("region=us-west,host=hostB")},
}},
influxql.IteratorOptions{
Expr: MustParseExpr(`last("value")`),
Dimensions: []string{"host"},
Interval: influxql.Interval{Duration: 5 * time.Nanosecond},
},
)
Fixed a bug in first() and last() where the time was lost last() would always return the last output of the iterator (which isn't necessarily the last time value due to how the merge iterator works) and first() would always return the first output of the iterator (wrong for the same reason). Now the time is kept by the reduce function and the times are wiped as part of the reduce iterator after the value has been found.
2016-01-23 03:04:10 +00:00
if a, ok := CompareFloatIterator(itr, []influxql.FloatPoint{
{Time: 0, Value: 10, Tags: ParseTags("host=hostA")},
{Time: 0, Value: 11, Tags: ParseTags("host=hostB")},
{Time: 5, Value: 20, Tags: ParseTags("host=hostA")},
{Time: 20, Value: 8, Tags: ParseTags("host=hostB")},
}); !ok {
t.Fatalf("unexpected points: %s", spew.Sdump(a))
}
}
// Ensure that an integer iterator can be created for a last() call.
func TestCallIterator_Last_Integer(t *testing.T) {
itr := influxql.NewCallIterator(
&IntegerIterator{Points: []influxql.IntegerPoint{
{Time: 1, Value: 11, Tags: ParseTags("region=us-west,host=hostB")},
{Time: 2, Value: 10, Tags: ParseTags("region=us-east,host=hostA")},
{Time: 0, Value: 15, Tags: ParseTags("region=us-east,host=hostA")},
{Time: 1, Value: 10, Tags: ParseTags("region=us-west,host=hostA")},
{Time: 6, Value: 20, Tags: ParseTags("region=us-east,host=hostA")},
{Time: 23, Value: 8, Tags: ParseTags("region=us-west,host=hostB")},
}},
influxql.IteratorOptions{
Expr: MustParseExpr(`last("value")`),
Dimensions: []string{"host"},
Interval: influxql.Interval{Duration: 5 * time.Nanosecond},
},
)
if a, ok := CompareIntegerIterator(itr, []influxql.IntegerPoint{
{Time: 0, Value: 10, Tags: ParseTags("host=hostA")},
{Time: 0, Value: 11, Tags: ParseTags("host=hostB")},
{Time: 5, Value: 20, Tags: ParseTags("host=hostA")},
{Time: 20, Value: 8, Tags: ParseTags("host=hostB")},
}); !ok {
refactor query engine
2015-11-04 21:06:06 +00:00
t.Fatalf("unexpected points: %s", spew.Sdump(a))
}
}
func BenchmarkCallIterator_Min_Float(b *testing.B) {
input := GenerateFloatIterator(rand.New(rand.NewSource(0)), b.N)
b.ResetTimer()
b.ReportAllocs()
itr := influxql.NewCallIterator(input, influxql.IteratorOptions{
Expr: MustParseExpr("min(value)"),
Interval: influxql.Interval{Duration: 1 * time.Hour},
}).(influxql.FloatIterator)
for {
if p := itr.Next(); p == nil {
break
}
}
}