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

2944 lines
134 KiB
Go
Raw Normal View History

Separate the query engine into a separate package This change provides a clear separation between the query engine mechanics and the query language so that the language can be parsed and dealt with separate from the query engine itself.
2017-08-15 19:24:22 +00:00
package query_test
refactor query engine
2015-11-04 21:06:06 +00:00
import (
Update SHOW TAG VALUES to use a fast dedupe iterator Include a benchmark test for the fast dedupe iterator.
2016-06-03 03:03:57 +00:00
"fmt"
Optimize top() and bottom() using an incremental aggregator The previous version of `top()` and `bottom()` would gather all of the points to use in a slice, filter them (if necessary), then use a slightly modified heap sort to retrieve the top or bottom values. This performed horrendously from the standpoint of memory. Since it consumed so much memory and spent so much time in allocations (along with sorting a potentially very large slice), this affected speed too. These calls have now been modified so they keep the top or bottom points in a min or max heap. For `top()`, a new point will read the minimum value from the heap. If the new point is greater than the minimum point, it will replace the minimum point and fix the heap with the new value. If the new point is smaller, it discards that point. For `bottom()`, the process is the opposite. It will then sort the final result to ensure the correct ordering of the selected points. When `top()` or `bottom()` contain a tag to select, they have now been modified so this query: SELECT top(value, host, 2) FROM cpu Essentially becomes this query: SELECT top(value, 2), host FROM ( SELECT max(value) FROM cpu GROUP BY host ) This should drastically increase the performance of all `top()` and `bottom()` queries.
2017-05-16 17:37:39 +00:00
"math/rand"
refactor query engine
2015-11-04 21:06:06 +00:00
"reflect"
"testing"
"time"
"github.com/davecgh/go-spew/spew"
Switch influxql to use google/go-cmp to compare the point structs The diff will improve the debug message when a test fails. Right now, the message is unreadable. The diff message from go-cmp is much better.
2017-07-21 18:07:46 +00:00
"github.com/google/go-cmp/cmp"
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"
Separate the query engine into a separate package This change provides a clear separation between the query engine mechanics and the query language so that the language can be parsed and dealt with separate from the query engine itself.
2017-08-15 19:24:22 +00:00
"github.com/influxdata/influxdb/query"
refactor query engine
2015-11-04 21:06:06 +00:00
)
// Second represents a helper for type converting durations.
const Second = int64(time.Second)
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
func TestSelect(t *testing.T) {
for _, tt := range []struct {
name string
q string
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ influxql.DataType
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
expr string
itrs []query.Iterator
points [][]query.Point
err string
}{
Support integers with top() and bottom() and fix point ordering top() and bottom() point ordering was incorrect and using an inefficient method of sorting. It has now been updated to use a heap and ordering is being done by value first and time second (with earlier times always taking priority). Removed unit tests that test using `time` inside of the query to get the real time instead of the interval time and only allowing the default behavior. We will have another mechanism to get the real time during an interval, but the current method is deprecated. The top() and bottom() methods now have integer support.
2016-02-02 20:23:06 +00:00
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
name: "Min",
q: `SELECT min(value) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-02T00:00:00Z' GROUP BY time(10s), host fill(none)`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Float,
expr: `min(value::float)`,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 0 * Second, Value: 20},
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 11 * Second, Value: 3},
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 31 * Second, Value: 100},
}},
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 9 * Second, Value: 19},
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 10 * Second, Value: 2},
}},
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 5 * Second, Value: 10},
}},
},
points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 0 * Second, Value: 19, Aggregated: 2}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 10 * Second, Value: 2, Aggregated: 2}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 30 * Second, Value: 100, Aggregated: 1}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=B"), Time: 0 * Second, Value: 10, Aggregated: 1}},
},
Support integers with top() and bottom() and fix point ordering top() and bottom() point ordering was incorrect and using an inefficient method of sorting. It has now been updated to use a heap and ordering is being done by value first and time second (with earlier times always taking priority). Removed unit tests that test using `time` inside of the query to get the real time instead of the interval time and only allowing the default behavior. We will have another mechanism to get the real time during an interval, but the current method is deprecated. The top() and bottom() methods now have integer support.
2016-02-02 20:23:06 +00:00
},
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
name: "Distinct_Float",
q: `SELECT distinct(value) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-02T00:00:00Z' GROUP BY time(10s), host fill(none)`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Float,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 0 * Second, Value: 20},
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 1 * Second, Value: 19},
}},
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 5 * Second, Value: 10},
}},
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 9 * Second, Value: 19},
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 10 * Second, Value: 2},
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 11 * Second, Value: 2},
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 12 * Second, Value: 2},
}},
},
points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 0 * Second, Value: 20}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 0 * Second, Value: 19}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 10 * Second, Value: 2}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=B"), Time: 0 * Second, Value: 10}},
},
Support integers with top() and bottom() and fix point ordering top() and bottom() point ordering was incorrect and using an inefficient method of sorting. It has now been updated to use a heap and ordering is being done by value first and time second (with earlier times always taking priority). Removed unit tests that test using `time` inside of the query to get the real time instead of the interval time and only allowing the default behavior. We will have another mechanism to get the real time during an interval, but the current method is deprecated. The top() and bottom() methods now have integer support.
2016-02-02 20:23:06 +00:00
},
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
name: "Distinct_Integer",
q: `SELECT distinct(value) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-02T00:00:00Z' GROUP BY time(10s), host fill(none)`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Integer,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&IntegerIterator{Points: []query.IntegerPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 0 * Second, Value: 20},
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 1 * Second, Value: 19},
}},
&IntegerIterator{Points: []query.IntegerPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 5 * Second, Value: 10},
}},
&IntegerIterator{Points: []query.IntegerPoint{
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 9 * Second, Value: 19},
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 10 * Second, Value: 2},
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 11 * Second, Value: 2},
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 12 * Second, Value: 2},
}},
},
points: [][]query.Point{
{&query.IntegerPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 0 * Second, Value: 20}},
{&query.IntegerPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 0 * Second, Value: 19}},
{&query.IntegerPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 10 * Second, Value: 2}},
{&query.IntegerPoint{Name: "cpu", Tags: ParseTags("host=B"), Time: 0 * Second, Value: 10}},
},
Support integers with top() and bottom() and fix point ordering top() and bottom() point ordering was incorrect and using an inefficient method of sorting. It has now been updated to use a heap and ordering is being done by value first and time second (with earlier times always taking priority). Removed unit tests that test using `time` inside of the query to get the real time instead of the interval time and only allowing the default behavior. We will have another mechanism to get the real time during an interval, but the current method is deprecated. The top() and bottom() methods now have integer support.
2016-02-02 20:23:06 +00:00
},
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
name: "Distinct_String",
q: `SELECT distinct(value) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-02T00:00:00Z' GROUP BY time(10s), host fill(none)`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.String,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&StringIterator{Points: []query.StringPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 0 * Second, Value: "a"},
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 1 * Second, Value: "b"},
}},
&StringIterator{Points: []query.StringPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 5 * Second, Value: "c"},
}},
&StringIterator{Points: []query.StringPoint{
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 9 * Second, Value: "b"},
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 10 * Second, Value: "d"},
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 11 * Second, Value: "d"},
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 12 * Second, Value: "d"},
}},
},
points: [][]query.Point{
{&query.StringPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 0 * Second, Value: "a"}},
{&query.StringPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 0 * Second, Value: "b"}},
{&query.StringPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 10 * Second, Value: "d"}},
{&query.StringPoint{Name: "cpu", Tags: ParseTags("host=B"), Time: 0 * Second, Value: "c"}},
},
Support integers with top() and bottom() and fix point ordering top() and bottom() point ordering was incorrect and using an inefficient method of sorting. It has now been updated to use a heap and ordering is being done by value first and time second (with earlier times always taking priority). Removed unit tests that test using `time` inside of the query to get the real time instead of the interval time and only allowing the default behavior. We will have another mechanism to get the real time during an interval, but the current method is deprecated. The top() and bottom() methods now have integer support.
2016-02-02 20:23:06 +00:00
},
Improved influxql package code coverage to 70%
2016-02-09 16:25:16 +00:00
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
name: "Distinct_Boolean",
q: `SELECT distinct(value) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-02T00:00:00Z' GROUP BY time(10s), host fill(none)`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Boolean,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&BooleanIterator{Points: []query.BooleanPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 0 * Second, Value: true},
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 1 * Second, Value: false},
}},
&BooleanIterator{Points: []query.BooleanPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 5 * Second, Value: false},
}},
&BooleanIterator{Points: []query.BooleanPoint{
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 9 * Second, Value: true},
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 10 * Second, Value: false},
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 11 * Second, Value: false},
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 12 * Second, Value: true},
}},
},
points: [][]query.Point{
{&query.BooleanPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 0 * Second, Value: true}},
{&query.BooleanPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 0 * Second, Value: false}},
{&query.BooleanPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 10 * Second, Value: false}},
{&query.BooleanPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 10 * Second, Value: true}},
{&query.BooleanPoint{Name: "cpu", Tags: ParseTags("host=B"), Time: 0 * Second, Value: false}},
},
Improved influxql package code coverage to 70%
2016-02-09 16:25:16 +00:00
},
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
name: "Mean_Float",
q: `SELECT mean(value) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-02T00:00:00Z' GROUP BY time(10s), host fill(none)`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Float,
expr: `mean(value::float)`,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 0 * Second, Value: 20},
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 11 * Second, Value: 3},
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 31 * Second, Value: 100},
}},
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 5 * Second, Value: 10},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 50 * Second, Value: 1},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 51 * Second, Value: 2},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 52 * Second, Value: 4},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 53 * Second, Value: 4},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 53 * Second, Value: 5},
}},
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 9 * Second, Value: 19},
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 10 * Second, Value: 2},
}},
},
points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 0 * Second, Value: 19.5, Aggregated: 2}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 10 * Second, Value: 2.5, Aggregated: 2}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 30 * Second, Value: 100, Aggregated: 1}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=B"), Time: 0 * Second, Value: 10, Aggregated: 1}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=B"), Time: 50 * Second, Value: 3.2, Aggregated: 5}},
},
Improved influxql package code coverage to 70%
2016-02-09 16:25:16 +00:00
},
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
name: "Mean_Integer",
q: `SELECT mean(value) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-02T00:00:00Z' GROUP BY time(10s), host fill(none)`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Integer,
expr: `mean(value::integer)`,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&IntegerIterator{Points: []query.IntegerPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 0 * Second, Value: 20},
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 11 * Second, Value: 3},
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 31 * Second, Value: 100},
}},
&IntegerIterator{Points: []query.IntegerPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 5 * Second, Value: 10},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 50 * Second, Value: 1},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 51 * Second, Value: 2},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 52 * Second, Value: 4},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 53 * Second, Value: 4},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 53 * Second, Value: 5},
}},
&IntegerIterator{Points: []query.IntegerPoint{
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 9 * Second, Value: 19},
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 10 * Second, Value: 2},
}},
},
points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 0 * Second, Value: 19.5, Aggregated: 2}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 10 * Second, Value: 2.5, Aggregated: 2}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 30 * Second, Value: 100, Aggregated: 1}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=B"), Time: 0 * Second, Value: 10, Aggregated: 1}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=B"), Time: 50 * Second, Value: 3.2, Aggregated: 5}},
},
Improved influxql package code coverage to 70%
2016-02-09 16:25:16 +00:00
},
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
name: "Mean_String",
q: `SELECT mean(value) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-02T00:00:00Z' GROUP BY time(10s), host fill(none)`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.String,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{&StringIterator{}},
err: `unsupported mean iterator type: *query_test.StringIterator`,
},
{
name: "Mean_Boolean",
q: `SELECT mean(value) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-02T00:00:00Z' GROUP BY time(10s), host fill(none)`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Boolean,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{&BooleanIterator{}},
err: `unsupported mean iterator type: *query_test.BooleanIterator`,
},
{
name: "Median_Float",
q: `SELECT median(value) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-02T00:00:00Z' GROUP BY time(10s), host fill(none)`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Float,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 0 * Second, Value: 20},
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 11 * Second, Value: 3},
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 31 * Second, Value: 100},
}},
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 5 * Second, Value: 10},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 50 * Second, Value: 1},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 51 * Second, Value: 2},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 52 * Second, Value: 3},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 53 * Second, Value: 4},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 53 * Second, Value: 5},
}},
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 9 * Second, Value: 19},
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 10 * Second, Value: 2},
}},
},
points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 0 * Second, Value: 19.5}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 10 * Second, Value: 2.5}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 30 * Second, Value: 100}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=B"), Time: 0 * Second, Value: 10}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=B"), Time: 50 * Second, Value: 3}},
},
Improved influxql package code coverage to 70%
2016-02-09 16:25:16 +00:00
},
Support integers with top() and bottom() and fix point ordering top() and bottom() point ordering was incorrect and using an inefficient method of sorting. It has now been updated to use a heap and ordering is being done by value first and time second (with earlier times always taking priority). Removed unit tests that test using `time` inside of the query to get the real time instead of the interval time and only allowing the default behavior. We will have another mechanism to get the real time during an interval, but the current method is deprecated. The top() and bottom() methods now have integer support.
2016-02-02 20:23:06 +00:00
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
name: "Median_Integer",
q: `SELECT median(value) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-02T00:00:00Z' GROUP BY time(10s), host fill(none)`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Integer,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&IntegerIterator{Points: []query.IntegerPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 0 * Second, Value: 20},
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 11 * Second, Value: 3},
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 31 * Second, Value: 100},
}},
&IntegerIterator{Points: []query.IntegerPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 5 * Second, Value: 10},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 50 * Second, Value: 1},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 51 * Second, Value: 2},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 52 * Second, Value: 3},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 53 * Second, Value: 4},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 53 * Second, Value: 5},
}},
&IntegerIterator{Points: []query.IntegerPoint{
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 9 * Second, Value: 19},
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 10 * Second, Value: 2},
}},
},
points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 0 * Second, Value: 19.5}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 10 * Second, Value: 2.5}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 30 * Second, Value: 100}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=B"), Time: 0 * Second, Value: 10}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=B"), Time: 50 * Second, Value: 3}},
},
Support integers with top() and bottom() and fix point ordering top() and bottom() point ordering was incorrect and using an inefficient method of sorting. It has now been updated to use a heap and ordering is being done by value first and time second (with earlier times always taking priority). Removed unit tests that test using `time` inside of the query to get the real time instead of the interval time and only allowing the default behavior. We will have another mechanism to get the real time during an interval, but the current method is deprecated. The top() and bottom() methods now have integer support.
2016-02-02 20:23:06 +00:00
},
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
name: "Median_String",
q: `SELECT median(value) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-02T00:00:00Z' GROUP BY time(10s), host fill(none)`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.String,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{&StringIterator{}},
err: `unsupported median iterator type: *query_test.StringIterator`,
},
{
name: "Median_Boolean",
q: `SELECT median(value) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-02T00:00:00Z' GROUP BY time(10s), host fill(none)`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Boolean,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{&BooleanIterator{}},
err: `unsupported median iterator type: *query_test.BooleanIterator`,
},
{
name: "Mode_Float",
q: `SELECT mode(value) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-02T00:00:00Z' GROUP BY time(10s), host fill(none)`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Float,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 0 * Second, Value: 10},
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 11 * Second, Value: 2},
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 31 * Second, Value: 100},
}},
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 5 * Second, Value: 10},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 50 * Second, Value: 1},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 51 * Second, Value: 2},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 52 * Second, Value: 3},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 53 * Second, Value: 4},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 53 * Second, Value: 5},
}},
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 9 * Second, Value: 19},
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 10 * Second, Value: 2},
}},
},
points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 0 * Second, Value: 10}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 10 * Second, Value: 2}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 30 * Second, Value: 100}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=B"), Time: 0 * Second, Value: 10}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=B"), Time: 50 * Second, Value: 1}},
},
Support integers with top() and bottom() and fix point ordering top() and bottom() point ordering was incorrect and using an inefficient method of sorting. It has now been updated to use a heap and ordering is being done by value first and time second (with earlier times always taking priority). Removed unit tests that test using `time` inside of the query to get the real time instead of the interval time and only allowing the default behavior. We will have another mechanism to get the real time during an interval, but the current method is deprecated. The top() and bottom() methods now have integer support.
2016-02-02 20:23:06 +00:00
},
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
name: "Mode_Integer",
q: `SELECT mode(value) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-02T00:00:00Z' GROUP BY time(10s), host fill(none)`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Integer,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&IntegerIterator{Points: []query.IntegerPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 0 * Second, Value: 10},
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 11 * Second, Value: 2},
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 31 * Second, Value: 100},
}},
&IntegerIterator{Points: []query.IntegerPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 5 * Second, Value: 10},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 50 * Second, Value: 1},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 51 * Second, Value: 2},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 52 * Second, Value: 3},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 53 * Second, Value: 4},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 54 * Second, Value: 5},
}},
&IntegerIterator{Points: []query.IntegerPoint{
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 9 * Second, Value: 19},
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 10 * Second, Value: 2},
}},
},
points: [][]query.Point{
{&query.IntegerPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 0 * Second, Value: 10}},
{&query.IntegerPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 10 * Second, Value: 2}},
{&query.IntegerPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 30 * Second, Value: 100}},
{&query.IntegerPoint{Name: "cpu", Tags: ParseTags("host=B"), Time: 0 * Second, Value: 10}},
{&query.IntegerPoint{Name: "cpu", Tags: ParseTags("host=B"), Time: 50 * Second, Value: 1}},
},
Support integers with top() and bottom() and fix point ordering top() and bottom() point ordering was incorrect and using an inefficient method of sorting. It has now been updated to use a heap and ordering is being done by value first and time second (with earlier times always taking priority). Removed unit tests that test using `time` inside of the query to get the real time instead of the interval time and only allowing the default behavior. We will have another mechanism to get the real time during an interval, but the current method is deprecated. The top() and bottom() methods now have integer support.
2016-02-02 20:23:06 +00:00
},
Improved influxql package code coverage to 70%
2016-02-09 16:25:16 +00:00
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
name: "Mode_String",
q: `SELECT mode(value) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-02T00:00:00Z' GROUP BY time(10s), host fill(none)`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.String,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&StringIterator{Points: []query.StringPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 0 * Second, Value: "a"},
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 1 * Second, Value: "a"},
}},
&StringIterator{Points: []query.StringPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 5 * Second, Value: "cxxx"},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 6 * Second, Value: "zzzz"},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 7 * Second, Value: "zzzz"},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 8 * Second, Value: "zxxx"},
}},
&StringIterator{Points: []query.StringPoint{
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 9 * Second, Value: "b"},
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 10 * Second, Value: "d"},
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 11 * Second, Value: "d"},
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 12 * Second, Value: "d"},
}},
},
points: [][]query.Point{
{&query.StringPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 0 * Second, Value: "a"}},
{&query.StringPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 10 * Second, Value: "d"}},
{&query.StringPoint{Name: "cpu", Tags: ParseTags("host=B"), Time: 0 * Second, Value: "zzzz"}},
},
Improved influxql package code coverage to 70%
2016-02-09 16:25:16 +00:00
},
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
name: "Mode_Boolean",
q: `SELECT mode(value) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-02T00:00:00Z' GROUP BY time(10s), host fill(none)`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Boolean,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&BooleanIterator{Points: []query.BooleanPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 0 * Second, Value: true},
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 1 * Second, Value: false},
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 2 * Second, Value: false},
}},
&BooleanIterator{Points: []query.BooleanPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 5 * Second, Value: true},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 6 * Second, Value: false},
}},
&BooleanIterator{Points: []query.BooleanPoint{
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 9 * Second, Value: false},
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 10 * Second, Value: true},
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 11 * Second, Value: false},
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 12 * Second, Value: true},
}},
},
points: [][]query.Point{
{&query.BooleanPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 0 * Second, Value: false}},
{&query.BooleanPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 10 * Second, Value: true}},
{&query.BooleanPoint{Name: "cpu", Tags: ParseTags("host=B"), Time: 0 * Second, Value: true}},
},
Improved influxql package code coverage to 70%
2016-02-09 16:25:16 +00:00
},
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
name: "Top_NoTags_Float",
q: `SELECT top(value, 2) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-02T00:00:00Z' GROUP BY time(30s), host fill(none)`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Float,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 0 * Second, Value: 20},
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 11 * Second, Value: 3},
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 31 * Second, Value: 100},
}},
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 5 * Second, Value: 10},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 50 * Second, Value: 1},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 51 * Second, Value: 2},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 52 * Second, Value: 3},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 53 * Second, Value: 4},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 53 * Second, Value: 5},
}},
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 9 * Second, Value: 19},
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 10 * Second, Value: 2},
}},
},
points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 0 * Second, Value: 20}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 9 * Second, Value: 19}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 31 * Second, Value: 100}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=B"), Time: 5 * Second, Value: 10}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=B"), Time: 53 * Second, Value: 5}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=B"), Time: 53 * Second, Value: 4}},
},
Improved influxql package code coverage to 70%
2016-02-09 16:25:16 +00:00
},
Support integers with top() and bottom() and fix point ordering top() and bottom() point ordering was incorrect and using an inefficient method of sorting. It has now been updated to use a heap and ordering is being done by value first and time second (with earlier times always taking priority). Removed unit tests that test using `time` inside of the query to get the real time instead of the interval time and only allowing the default behavior. We will have another mechanism to get the real time during an interval, but the current method is deprecated. The top() and bottom() methods now have integer support.
2016-02-02 20:23:06 +00:00
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
name: "Top_NoTags_Integer",
q: `SELECT top(value, 2) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-02T00:00:00Z' GROUP BY time(30s), host fill(none)`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Integer,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&IntegerIterator{Points: []query.IntegerPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 0 * Second, Value: 20},
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 11 * Second, Value: 3},
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 31 * Second, Value: 100},
}},
&IntegerIterator{Points: []query.IntegerPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 5 * Second, Value: 10},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 50 * Second, Value: 1},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 51 * Second, Value: 2},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 52 * Second, Value: 3},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 53 * Second, Value: 4},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 53 * Second, Value: 5},
}},
&IntegerIterator{Points: []query.IntegerPoint{
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 9 * Second, Value: 19},
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 10 * Second, Value: 2},
}},
},
points: [][]query.Point{
{&query.IntegerPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 0 * Second, Value: 20}},
{&query.IntegerPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 9 * Second, Value: 19}},
{&query.IntegerPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 31 * Second, Value: 100}},
{&query.IntegerPoint{Name: "cpu", Tags: ParseTags("host=B"), Time: 5 * Second, Value: 10}},
{&query.IntegerPoint{Name: "cpu", Tags: ParseTags("host=B"), Time: 53 * Second, Value: 5}},
{&query.IntegerPoint{Name: "cpu", Tags: ParseTags("host=B"), Time: 53 * Second, Value: 4}},
},
Support integers with top() and bottom() and fix point ordering top() and bottom() point ordering was incorrect and using an inefficient method of sorting. It has now been updated to use a heap and ordering is being done by value first and time second (with earlier times always taking priority). Removed unit tests that test using `time` inside of the query to get the real time instead of the interval time and only allowing the default behavior. We will have another mechanism to get the real time during an interval, but the current method is deprecated. The top() and bottom() methods now have integer support.
2016-02-02 20:23:06 +00:00
},
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
name: "Top_Tags_Float",
q: `SELECT top(value::float, host::tag, 2) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-02T00:00:00Z' GROUP BY time(30s) fill(none)`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Float,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
expr: `max(value::float)`,
itrs: []query.Iterator{
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 0 * Second, Value: 20, Aux: []interface{}{"A"}},
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 11 * Second, Value: 3, Aux: []interface{}{"A"}},
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 31 * Second, Value: 100, Aux: []interface{}{"A"}},
}},
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 5 * Second, Value: 10, Aux: []interface{}{"B"}},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 50 * Second, Value: 1, Aux: []interface{}{"B"}},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 51 * Second, Value: 2, Aux: []interface{}{"B"}},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 52 * Second, Value: 3, Aux: []interface{}{"B"}},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 53 * Second, Value: 4, Aux: []interface{}{"B"}},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 53 * Second, Value: 5, Aux: []interface{}{"B"}},
}},
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 9 * Second, Value: 19, Aux: []interface{}{"A"}},
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 10 * Second, Value: 2, Aux: []interface{}{"A"}},
}},
},
points: [][]query.Point{
{
&query.FloatPoint{Name: "cpu", Time: 0 * Second, Value: 20, Aux: []interface{}{"A"}},
&query.StringPoint{Name: "cpu", Time: 0 * Second, Value: "A"},
},
{
&query.FloatPoint{Name: "cpu", Time: 5 * Second, Value: 10, Aux: []interface{}{"B"}},
&query.StringPoint{Name: "cpu", Time: 5 * Second, Value: "B"},
},
{
&query.FloatPoint{Name: "cpu", Time: 31 * Second, Value: 100, Aux: []interface{}{"A"}},
&query.StringPoint{Name: "cpu", Time: 31 * Second, Value: "A"},
},
{
&query.FloatPoint{Name: "cpu", Time: 53 * Second, Value: 5, Aux: []interface{}{"B"}},
&query.StringPoint{Name: "cpu", Time: 53 * Second, Value: "B"},
},
},
Support integers with top() and bottom() and fix point ordering top() and bottom() point ordering was incorrect and using an inefficient method of sorting. It has now been updated to use a heap and ordering is being done by value first and time second (with earlier times always taking priority). Removed unit tests that test using `time` inside of the query to get the real time instead of the interval time and only allowing the default behavior. We will have another mechanism to get the real time during an interval, but the current method is deprecated. The top() and bottom() methods now have integer support.
2016-02-02 20:23:06 +00:00
},
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
name: "Top_Tags_Integer",
q: `SELECT top(value::integer, host::tag, 2) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-02T00:00:00Z' GROUP BY time(30s) fill(none)`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Integer,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
expr: `max(value::integer)`,
itrs: []query.Iterator{
&IntegerIterator{Points: []query.IntegerPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 0 * Second, Value: 20, Aux: []interface{}{"A"}},
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 11 * Second, Value: 3, Aux: []interface{}{"A"}},
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 31 * Second, Value: 100, Aux: []interface{}{"A"}},
}},
&IntegerIterator{Points: []query.IntegerPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 5 * Second, Value: 10, Aux: []interface{}{"B"}},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 50 * Second, Value: 1, Aux: []interface{}{"B"}},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 51 * Second, Value: 2, Aux: []interface{}{"B"}},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 52 * Second, Value: 3, Aux: []interface{}{"B"}},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 53 * Second, Value: 4, Aux: []interface{}{"B"}},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 53 * Second, Value: 5, Aux: []interface{}{"B"}},
}},
&IntegerIterator{Points: []query.IntegerPoint{
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 9 * Second, Value: 19, Aux: []interface{}{"A"}},
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 10 * Second, Value: 2, Aux: []interface{}{"A"}},
}},
},
points: [][]query.Point{
{
&query.IntegerPoint{Name: "cpu", Time: 0 * Second, Value: 20, Aux: []interface{}{"A"}},
&query.StringPoint{Name: "cpu", Time: 0 * Second, Value: "A"},
},
{
&query.IntegerPoint{Name: "cpu", Time: 5 * Second, Value: 10, Aux: []interface{}{"B"}},
&query.StringPoint{Name: "cpu", Time: 5 * Second, Value: "B"},
},
{
&query.IntegerPoint{Name: "cpu", Time: 31 * Second, Value: 100, Aux: []interface{}{"A"}},
&query.StringPoint{Name: "cpu", Time: 31 * Second, Value: "A"},
},
{
&query.IntegerPoint{Name: "cpu", Time: 53 * Second, Value: 5, Aux: []interface{}{"B"}},
&query.StringPoint{Name: "cpu", Time: 53 * Second, Value: "B"},
},
},
Support integers with top() and bottom() and fix point ordering top() and bottom() point ordering was incorrect and using an inefficient method of sorting. It has now been updated to use a heap and ordering is being done by value first and time second (with earlier times always taking priority). Removed unit tests that test using `time` inside of the query to get the real time instead of the interval time and only allowing the default behavior. We will have another mechanism to get the real time during an interval, but the current method is deprecated. The top() and bottom() methods now have integer support.
2016-02-02 20:23:06 +00:00
},
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
name: "Top_GroupByTags_Float",
q: `SELECT top(value::float, host::tag, 1) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-02T00:00:00Z' GROUP BY region, time(30s) fill(none)`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Float,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
expr: `max(value::float)`,
itrs: []query.Iterator{
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 0 * Second, Value: 20, Aux: []interface{}{"A"}},
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 11 * Second, Value: 3, Aux: []interface{}{"A"}},
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 31 * Second, Value: 100, Aux: []interface{}{"A"}},
}},
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 5 * Second, Value: 10, Aux: []interface{}{"B"}},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 50 * Second, Value: 1, Aux: []interface{}{"B"}},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 51 * Second, Value: 2, Aux: []interface{}{"B"}},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 52 * Second, Value: 3, Aux: []interface{}{"B"}},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 53 * Second, Value: 4, Aux: []interface{}{"B"}},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 53 * Second, Value: 5, Aux: []interface{}{"B"}},
}},
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 9 * Second, Value: 19, Aux: []interface{}{"A"}},
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 10 * Second, Value: 2, Aux: []interface{}{"A"}},
}},
},
points: [][]query.Point{
{
&query.FloatPoint{Name: "cpu", Tags: ParseTags("region=east"), Time: 9 * Second, Value: 19, Aux: []interface{}{"A"}},
&query.StringPoint{Name: "cpu", Tags: ParseTags("region=east"), Time: 9 * Second, Value: "A"},
},
{
&query.FloatPoint{Name: "cpu", Tags: ParseTags("region=west"), Time: 0 * Second, Value: 20, Aux: []interface{}{"A"}},
&query.StringPoint{Name: "cpu", Tags: ParseTags("region=west"), Time: 0 * Second, Value: "A"},
},
{
&query.FloatPoint{Name: "cpu", Tags: ParseTags("region=west"), Time: 31 * Second, Value: 100, Aux: []interface{}{"A"}},
&query.StringPoint{Name: "cpu", Tags: ParseTags("region=west"), Time: 31 * Second, Value: "A"},
},
},
Support integers with top() and bottom() and fix point ordering top() and bottom() point ordering was incorrect and using an inefficient method of sorting. It has now been updated to use a heap and ordering is being done by value first and time second (with earlier times always taking priority). Removed unit tests that test using `time` inside of the query to get the real time instead of the interval time and only allowing the default behavior. We will have another mechanism to get the real time during an interval, but the current method is deprecated. The top() and bottom() methods now have integer support.
2016-02-02 20:23:06 +00:00
},
Improved influxql package code coverage to 70%
2016-02-09 16:25:16 +00:00
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
name: "Top_GroupByTags_Integer",
q: `SELECT top(value::integer, host::tag, 1) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-02T00:00:00Z' GROUP BY region, time(30s) fill(none)`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Integer,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&IntegerIterator{Points: []query.IntegerPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 0 * Second, Value: 20, Aux: []interface{}{"A"}},
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 11 * Second, Value: 3, Aux: []interface{}{"A"}},
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 31 * Second, Value: 100, Aux: []interface{}{"A"}},
}},
&IntegerIterator{Points: []query.IntegerPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 5 * Second, Value: 10, Aux: []interface{}{"B"}},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 50 * Second, Value: 1, Aux: []interface{}{"B"}},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 51 * Second, Value: 2, Aux: []interface{}{"B"}},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 52 * Second, Value: 3, Aux: []interface{}{"B"}},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 53 * Second, Value: 4, Aux: []interface{}{"B"}},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 53 * Second, Value: 5, Aux: []interface{}{"B"}},
}},
&IntegerIterator{Points: []query.IntegerPoint{
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 9 * Second, Value: 19, Aux: []interface{}{"A"}},
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 10 * Second, Value: 2, Aux: []interface{}{"A"}},
}},
},
points: [][]query.Point{
{
&query.IntegerPoint{Name: "cpu", Tags: ParseTags("region=east"), Time: 9 * Second, Value: 19, Aux: []interface{}{"A"}},
&query.StringPoint{Name: "cpu", Tags: ParseTags("region=east"), Time: 9 * Second, Value: "A"},
},
{
&query.IntegerPoint{Name: "cpu", Tags: ParseTags("region=west"), Time: 0 * Second, Value: 20, Aux: []interface{}{"A"}},
&query.StringPoint{Name: "cpu", Tags: ParseTags("region=west"), Time: 0 * Second, Value: "A"},
},
{
&query.IntegerPoint{Name: "cpu", Tags: ParseTags("region=west"), Time: 31 * Second, Value: 100, Aux: []interface{}{"A"}},
&query.StringPoint{Name: "cpu", Tags: ParseTags("region=west"), Time: 31 * Second, Value: "A"},
},
},
Improved influxql package code coverage to 70%
2016-02-09 16:25:16 +00:00
},
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
name: "Bottom_NoTags_Float",
q: `SELECT bottom(value::float, 2) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-02T00:00:00Z' GROUP BY time(30s), host fill(none)`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Float,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 0 * Second, Value: 20},
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 11 * Second, Value: 3},
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 31 * Second, Value: 100},
}},
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 5 * Second, Value: 10},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 50 * Second, Value: 1},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 51 * Second, Value: 2},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 52 * Second, Value: 3},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 53 * Second, Value: 4},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 53 * Second, Value: 5},
}},
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 9 * Second, Value: 19},
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 10 * Second, Value: 2},
}},
},
points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 10 * Second, Value: 2}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 11 * Second, Value: 3}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 31 * Second, Value: 100}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=B"), Time: 5 * Second, Value: 10}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=B"), Time: 50 * Second, Value: 1}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=B"), Time: 51 * Second, Value: 2}},
},
Improved influxql package code coverage to 70%
2016-02-09 16:25:16 +00:00
},
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
name: "Bottom_NoTags_Integer",
q: `SELECT bottom(value::integer, 2) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-02T00:00:00Z' GROUP BY time(30s), host fill(none)`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Integer,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&IntegerIterator{Points: []query.IntegerPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 0 * Second, Value: 20},
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 11 * Second, Value: 3},
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 31 * Second, Value: 100},
}},
&IntegerIterator{Points: []query.IntegerPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 5 * Second, Value: 10},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 50 * Second, Value: 1},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 51 * Second, Value: 2},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 52 * Second, Value: 3},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 53 * Second, Value: 4},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 53 * Second, Value: 5},
}},
&IntegerIterator{Points: []query.IntegerPoint{
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 9 * Second, Value: 19},
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 10 * Second, Value: 2},
}},
},
points: [][]query.Point{
{&query.IntegerPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 10 * Second, Value: 2}},
{&query.IntegerPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 11 * Second, Value: 3}},
{&query.IntegerPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 31 * Second, Value: 100}},
{&query.IntegerPoint{Name: "cpu", Tags: ParseTags("host=B"), Time: 5 * Second, Value: 10}},
{&query.IntegerPoint{Name: "cpu", Tags: ParseTags("host=B"), Time: 50 * Second, Value: 1}},
{&query.IntegerPoint{Name: "cpu", Tags: ParseTags("host=B"), Time: 51 * Second, Value: 2}},
},
Improved influxql package code coverage to 70%
2016-02-09 16:25:16 +00:00
},
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
name: "Bottom_Tags_Float",
q: `SELECT bottom(value::float, host::tag, 2) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-02T00:00:00Z' GROUP BY time(30s) fill(none)`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Float,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
expr: `min(value::float)`,
itrs: []query.Iterator{
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 0 * Second, Value: 20, Aux: []interface{}{"A"}},
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 11 * Second, Value: 3, Aux: []interface{}{"A"}},
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 31 * Second, Value: 100, Aux: []interface{}{"A"}},
}},
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 5 * Second, Value: 10, Aux: []interface{}{"B"}},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 50 * Second, Value: 1, Aux: []interface{}{"B"}},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 51 * Second, Value: 2, Aux: []interface{}{"B"}},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 52 * Second, Value: 3, Aux: []interface{}{"B"}},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 53 * Second, Value: 4, Aux: []interface{}{"B"}},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 53 * Second, Value: 5, Aux: []interface{}{"B"}},
}},
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 9 * Second, Value: 19, Aux: []interface{}{"A"}},
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 10 * Second, Value: 2, Aux: []interface{}{"A"}},
}},
},
points: [][]query.Point{
{
&query.FloatPoint{Name: "cpu", Time: 5 * Second, Value: 10, Aux: []interface{}{"B"}},
&query.StringPoint{Name: "cpu", Time: 5 * Second, Value: "B"},
},
{
&query.FloatPoint{Name: "cpu", Time: 10 * Second, Value: 2, Aux: []interface{}{"A"}},
&query.StringPoint{Name: "cpu", Time: 10 * Second, Value: "A"},
},
{
&query.FloatPoint{Name: "cpu", Time: 31 * Second, Value: 100, Aux: []interface{}{"A"}},
&query.StringPoint{Name: "cpu", Time: 31 * Second, Value: "A"},
},
{
&query.FloatPoint{Name: "cpu", Time: 50 * Second, Value: 1, Aux: []interface{}{"B"}},
&query.StringPoint{Name: "cpu", Time: 50 * Second, Value: "B"},
},
},
Improved influxql package code coverage to 70%
2016-02-09 16:25:16 +00:00
},
Support integers with top() and bottom() and fix point ordering top() and bottom() point ordering was incorrect and using an inefficient method of sorting. It has now been updated to use a heap and ordering is being done by value first and time second (with earlier times always taking priority). Removed unit tests that test using `time` inside of the query to get the real time instead of the interval time and only allowing the default behavior. We will have another mechanism to get the real time during an interval, but the current method is deprecated. The top() and bottom() methods now have integer support.
2016-02-02 20:23:06 +00:00
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
name: "Bottom_Tags_Integer",
q: `SELECT bottom(value::integer, host::tag, 2) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-02T00:00:00Z' GROUP BY time(30s) fill(none)`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Integer,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&IntegerIterator{Points: []query.IntegerPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 0 * Second, Value: 20, Aux: []interface{}{"A"}},
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 11 * Second, Value: 3, Aux: []interface{}{"A"}},
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 31 * Second, Value: 100, Aux: []interface{}{"A"}},
}},
&IntegerIterator{Points: []query.IntegerPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 5 * Second, Value: 10, Aux: []interface{}{"B"}},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 50 * Second, Value: 1, Aux: []interface{}{"B"}},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 51 * Second, Value: 2, Aux: []interface{}{"B"}},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 52 * Second, Value: 3, Aux: []interface{}{"B"}},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 53 * Second, Value: 4, Aux: []interface{}{"B"}},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 53 * Second, Value: 5, Aux: []interface{}{"B"}},
}},
&IntegerIterator{Points: []query.IntegerPoint{
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 9 * Second, Value: 19, Aux: []interface{}{"A"}},
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 10 * Second, Value: 2, Aux: []interface{}{"A"}},
}},
},
points: [][]query.Point{
{
&query.IntegerPoint{Name: "cpu", Time: 5 * Second, Value: 10, Aux: []interface{}{"B"}},
&query.StringPoint{Name: "cpu", Time: 5 * Second, Value: "B"},
},
{
&query.IntegerPoint{Name: "cpu", Time: 10 * Second, Value: 2, Aux: []interface{}{"A"}},
&query.StringPoint{Name: "cpu", Time: 10 * Second, Value: "A"},
},
{
&query.IntegerPoint{Name: "cpu", Time: 31 * Second, Value: 100, Aux: []interface{}{"A"}},
&query.StringPoint{Name: "cpu", Time: 31 * Second, Value: "A"},
},
{
&query.IntegerPoint{Name: "cpu", Time: 50 * Second, Value: 1, Aux: []interface{}{"B"}},
&query.StringPoint{Name: "cpu", Time: 50 * Second, Value: "B"},
},
},
Support integers with top() and bottom() and fix point ordering top() and bottom() point ordering was incorrect and using an inefficient method of sorting. It has now been updated to use a heap and ordering is being done by value first and time second (with earlier times always taking priority). Removed unit tests that test using `time` inside of the query to get the real time instead of the interval time and only allowing the default behavior. We will have another mechanism to get the real time during an interval, but the current method is deprecated. The top() and bottom() methods now have integer support.
2016-02-02 20:23:06 +00:00
},
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
name: "Bottom_GroupByTags_Float",
q: `SELECT bottom(value::float, host::tag, 1) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-02T00:00:00Z' GROUP BY region, time(30s) fill(none)`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Float,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
expr: `min(value::float)`,
itrs: []query.Iterator{
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 0 * Second, Value: 20, Aux: []interface{}{"A"}},
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 11 * Second, Value: 3, Aux: []interface{}{"A"}},
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 31 * Second, Value: 100, Aux: []interface{}{"A"}},
}},
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 5 * Second, Value: 10, Aux: []interface{}{"B"}},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 50 * Second, Value: 1, Aux: []interface{}{"B"}},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 51 * Second, Value: 2, Aux: []interface{}{"B"}},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 52 * Second, Value: 3, Aux: []interface{}{"B"}},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 53 * Second, Value: 4, Aux: []interface{}{"B"}},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 53 * Second, Value: 5, Aux: []interface{}{"B"}},
}},
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 9 * Second, Value: 19, Aux: []interface{}{"A"}},
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 10 * Second, Value: 2, Aux: []interface{}{"A"}},
}},
},
points: [][]query.Point{
{
&query.FloatPoint{Name: "cpu", Tags: ParseTags("region=east"), Time: 10 * Second, Value: 2, Aux: []interface{}{"A"}},
&query.StringPoint{Name: "cpu", Tags: ParseTags("region=east"), Time: 10 * Second, Value: "A"},
},
{
&query.FloatPoint{Name: "cpu", Tags: ParseTags("region=west"), Time: 11 * Second, Value: 3, Aux: []interface{}{"A"}},
&query.StringPoint{Name: "cpu", Tags: ParseTags("region=west"), Time: 11 * Second, Value: "A"},
},
{
&query.FloatPoint{Name: "cpu", Tags: ParseTags("region=west"), Time: 50 * Second, Value: 1, Aux: []interface{}{"B"}},
&query.StringPoint{Name: "cpu", Tags: ParseTags("region=west"), Time: 50 * Second, Value: "B"},
},
},
Support integers with top() and bottom() and fix point ordering top() and bottom() point ordering was incorrect and using an inefficient method of sorting. It has now been updated to use a heap and ordering is being done by value first and time second (with earlier times always taking priority). Removed unit tests that test using `time` inside of the query to get the real time instead of the interval time and only allowing the default behavior. We will have another mechanism to get the real time during an interval, but the current method is deprecated. The top() and bottom() methods now have integer support.
2016-02-02 20:23:06 +00:00
},
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
name: "Bottom_GroupByTags_Integer",
q: `SELECT bottom(value::float, host::tag, 1) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-02T00:00:00Z' GROUP BY region, time(30s) fill(none)`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Integer,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
expr: `min(value::float)`,
itrs: []query.Iterator{
&IntegerIterator{Points: []query.IntegerPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 0 * Second, Value: 20, Aux: []interface{}{"A"}},
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 11 * Second, Value: 3, Aux: []interface{}{"A"}},
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 31 * Second, Value: 100, Aux: []interface{}{"A"}},
}},
&IntegerIterator{Points: []query.IntegerPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 5 * Second, Value: 10, Aux: []interface{}{"B"}},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 50 * Second, Value: 1, Aux: []interface{}{"B"}},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 51 * Second, Value: 2, Aux: []interface{}{"B"}},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 52 * Second, Value: 3, Aux: []interface{}{"B"}},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 53 * Second, Value: 4, Aux: []interface{}{"B"}},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 53 * Second, Value: 5, Aux: []interface{}{"B"}},
}},
&IntegerIterator{Points: []query.IntegerPoint{
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 9 * Second, Value: 19, Aux: []interface{}{"A"}},
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 10 * Second, Value: 2, Aux: []interface{}{"A"}},
}},
},
points: [][]query.Point{
{
&query.IntegerPoint{Name: "cpu", Tags: ParseTags("region=east"), Time: 10 * Second, Value: 2, Aux: []interface{}{"A"}},
&query.StringPoint{Name: "cpu", Tags: ParseTags("region=east"), Time: 10 * Second, Value: "A"},
},
{
&query.IntegerPoint{Name: "cpu", Tags: ParseTags("region=west"), Time: 11 * Second, Value: 3, Aux: []interface{}{"A"}},
&query.StringPoint{Name: "cpu", Tags: ParseTags("region=west"), Time: 11 * Second, Value: "A"},
},
{
&query.IntegerPoint{Name: "cpu", Tags: ParseTags("region=west"), Time: 50 * Second, Value: 1, Aux: []interface{}{"B"}},
&query.StringPoint{Name: "cpu", Tags: ParseTags("region=west"), Time: 50 * Second, Value: "B"},
},
},
Support integers with top() and bottom() and fix point ordering top() and bottom() point ordering was incorrect and using an inefficient method of sorting. It has now been updated to use a heap and ordering is being done by value first and time second (with earlier times always taking priority). Removed unit tests that test using `time` inside of the query to get the real time instead of the interval time and only allowing the default behavior. We will have another mechanism to get the real time during an interval, but the current method is deprecated. The top() and bottom() methods now have integer support.
2016-02-02 20:23:06 +00:00
},
Improved influxql package code coverage to 70%
2016-02-09 16:25:16 +00:00
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
name: "Fill_Null_Float",
q: `SELECT mean(value) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-01T00:01:00Z' GROUP BY host, time(10s) fill(null)`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Float,
expr: `mean(value::float)`,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Tags: ParseTags("host=A"), Time: 12 * Second, Value: 2},
}},
},
points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 0 * Second, Nil: true}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 10 * Second, Value: 2, Aggregated: 1}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 20 * Second, Nil: true}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 30 * Second, Nil: true}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 40 * Second, Nil: true}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 50 * Second, Nil: true}},
},
Improved influxql package code coverage to 70%
2016-02-09 16:25:16 +00:00
},
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
name: "Fill_Number_Float",
q: `SELECT mean(value) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-01T00:01:00Z' GROUP BY host, time(10s) fill(1)`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Float,
expr: `mean(value::float)`,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Tags: ParseTags("host=A"), Time: 12 * Second, Value: 2},
}},
},
points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 0 * Second, Value: 1}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 10 * Second, Value: 2, Aggregated: 1}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 20 * Second, Value: 1}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 30 * Second, Value: 1}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 40 * Second, Value: 1}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 50 * Second, Value: 1}},
},
Improved influxql package code coverage to 70%
2016-02-09 16:25:16 +00:00
},
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
name: "Fill_Previous_Float",
q: `SELECT mean(value) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-01T00:01:00Z' GROUP BY host, time(10s) fill(previous)`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Float,
expr: `mean(value::float)`,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Tags: ParseTags("host=A"), Time: 12 * Second, Value: 2},
}},
},
points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 0 * Second, Nil: true}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 10 * Second, Value: 2, Aggregated: 1}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 20 * Second, Value: 2}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 30 * Second, Value: 2}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 40 * Second, Value: 2}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 50 * Second, Value: 2}},
},
Improved influxql package code coverage to 70%
2016-02-09 16:25:16 +00:00
},
refactor query engine
2015-11-04 21:06:06 +00:00
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
name: "Fill_Linear_Float_One",
q: `SELECT mean(value) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-01T00:01:00Z' GROUP BY host, time(10s) fill(linear)`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Float,
expr: `mean(value::float)`,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Tags: ParseTags("host=A"), Time: 12 * Second, Value: 2},
{Name: "cpu", Tags: ParseTags("host=A"), Time: 32 * Second, Value: 4},
}},
},
points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 0 * Second, Nil: true}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 10 * Second, Value: 2, Aggregated: 1}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 20 * Second, Value: 3}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 30 * Second, Value: 4, Aggregated: 1}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 40 * Second, Nil: true}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 50 * Second, Nil: true}},
},
refactor query engine
2015-11-04 21:06:06 +00:00
},
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
name: "Fill_Linear_Float_Many",
q: `SELECT mean(value) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-01T00:01:00Z' GROUP BY host, time(10s) fill(linear)`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Float,
expr: `mean(value::float)`,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Tags: ParseTags("host=A"), Time: 12 * Second, Value: 2},
{Name: "cpu", Tags: ParseTags("host=A"), Time: 62 * Second, Value: 7},
}},
},
points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 0 * Second, Nil: true}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 10 * Second, Value: 2, Aggregated: 1}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 20 * Second, Value: 3}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 30 * Second, Value: 4}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 40 * Second, Value: 5}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 50 * Second, Value: 6}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 60 * Second, Value: 7, Aggregated: 1}},
},
refactor query engine
2015-11-04 21:06:06 +00:00
},
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
name: "Fill_Linear_Float_MultipleSeries",
q: `SELECT mean(value) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-01T00:01:00Z' GROUP BY host, time(10s) fill(linear)`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Float,
expr: `mean(value::float)`,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Tags: ParseTags("host=A"), Time: 12 * Second, Value: 2},
{Name: "cpu", Tags: ParseTags("host=B"), Time: 32 * Second, Value: 4},
}},
},
points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 0 * Second, Nil: true}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 10 * Second, Value: 2, Aggregated: 1}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 20 * Second, Nil: true}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 30 * Second, Nil: true}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 40 * Second, Nil: true}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 50 * Second, Nil: true}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=B"), Time: 0 * Second, Nil: true}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=B"), Time: 10 * Second, Nil: true}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=B"), Time: 20 * Second, Nil: true}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=B"), Time: 30 * Second, Value: 4, Aggregated: 1}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=B"), Time: 40 * Second, Nil: true}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=B"), Time: 50 * Second, Nil: true}},
},
refactor query engine
2015-11-04 21:06:06 +00:00
},
Add binary expr tests to influxql package No boolean operator tests because the parser doesn't currently allow it. I am currently keeping the code that performs this for now until we decide whether to allow boolean operators inside of a select clause. It would be easy to have the new query engine do something like this: SELECT mean(value) < 10 FROM cpu GROUP BY time(1m) And then you would have it return true or false for each interval, but the same can be done through a where clause too.
2016-02-01 22:08:37 +00:00
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
name: "Fill_Linear_Integer_One",
q: `SELECT max(value) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-01T00:01:00Z' GROUP BY host, time(10s) fill(linear)`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Integer,
expr: `max(value::integer)`,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&IntegerIterator{Points: []query.IntegerPoint{
{Name: "cpu", Tags: ParseTags("host=A"), Time: 12 * Second, Value: 1},
{Name: "cpu", Tags: ParseTags("host=A"), Time: 32 * Second, Value: 4},
}},
},
points: [][]query.Point{
{&query.IntegerPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 0 * Second, Nil: true}},
{&query.IntegerPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 10 * Second, Value: 1, Aggregated: 1}},
{&query.IntegerPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 20 * Second, Value: 2}},
{&query.IntegerPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 30 * Second, Value: 4, Aggregated: 1}},
{&query.IntegerPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 40 * Second, Nil: true}},
{&query.IntegerPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 50 * Second, Nil: true}},
Support integer literals in the query language Numbers in the query without any decimal will now be emitted as integers instead and be parsed as an IntegerLiteral. This ensures we keep the original context that a query was issued with and allows us to act more similar to how programming languages are typically structured when it comes to floats and ints. This adds functionality for dealing with integers promoting to floats in the various different places where math are used. Fixes #5744 and #5629.
2016-02-19 04:06:41 +00:00
},
},
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
name: "Fill_Linear_Integer_Many",
q: `SELECT max(value) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-01T00:01:20Z' GROUP BY host, time(10s) fill(linear)`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Integer,
expr: `max(value::integer)`,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&IntegerIterator{Points: []query.IntegerPoint{
{Name: "cpu", Tags: ParseTags("host=A"), Time: 12 * Second, Value: 1},
{Name: "cpu", Tags: ParseTags("host=A"), Time: 72 * Second, Value: 10},
}},
},
points: [][]query.Point{
{&query.IntegerPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 0 * Second, Nil: true}},
{&query.IntegerPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 10 * Second, Value: 1, Aggregated: 1}},
{&query.IntegerPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 20 * Second, Value: 2}},
{&query.IntegerPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 30 * Second, Value: 4}},
{&query.IntegerPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 40 * Second, Value: 5}},
{&query.IntegerPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 50 * Second, Value: 7}},
{&query.IntegerPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 60 * Second, Value: 8}},
{&query.IntegerPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 70 * Second, Value: 10, Aggregated: 1}},
Add binary expr tests to influxql package No boolean operator tests because the parser doesn't currently allow it. I am currently keeping the code that performs this for now until we decide whether to allow boolean operators inside of a select clause. It would be easy to have the new query engine do something like this: SELECT mean(value) < 10 FROM cpu GROUP BY time(1m) And then you would have it return true or false for each interval, but the same can be done through a where clause too.
2016-02-01 22:08:37 +00:00
},
},
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
name: "Fill_Linear_Integer_MultipleSeries",
q: `SELECT max(value) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-01T00:01:00Z' GROUP BY host, time(10s) fill(linear)`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Integer,
expr: `max(value::integer)`,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&IntegerIterator{Points: []query.IntegerPoint{
{Name: "cpu", Tags: ParseTags("host=A"), Time: 12 * Second, Value: 2},
{Name: "cpu", Tags: ParseTags("host=B"), Time: 32 * Second, Value: 4},
}},
},
points: [][]query.Point{
{&query.IntegerPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 0 * Second, Nil: true}},
{&query.IntegerPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 10 * Second, Value: 2, Aggregated: 1}},
{&query.IntegerPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 20 * Second, Nil: true}},
{&query.IntegerPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 30 * Second, Nil: true}},
{&query.IntegerPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 40 * Second, Nil: true}},
{&query.IntegerPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 50 * Second, Nil: true}},
{&query.IntegerPoint{Name: "cpu", Tags: ParseTags("host=B"), Time: 0 * Second, Nil: true}},
{&query.IntegerPoint{Name: "cpu", Tags: ParseTags("host=B"), Time: 10 * Second, Nil: true}},
{&query.IntegerPoint{Name: "cpu", Tags: ParseTags("host=B"), Time: 20 * Second, Nil: true}},
{&query.IntegerPoint{Name: "cpu", Tags: ParseTags("host=B"), Time: 30 * Second, Value: 4, Aggregated: 1}},
{&query.IntegerPoint{Name: "cpu", Tags: ParseTags("host=B"), Time: 40 * Second, Nil: true}},
{&query.IntegerPoint{Name: "cpu", Tags: ParseTags("host=B"), Time: 50 * Second, Nil: true}},
Support integer literals in the query language Numbers in the query without any decimal will now be emitted as integers instead and be parsed as an IntegerLiteral. This ensures we keep the original context that a query was issued with and allows us to act more similar to how programming languages are typically structured when it comes to floats and ints. This adds functionality for dealing with integers promoting to floats in the various different places where math are used. Fixes #5744 and #5629.
2016-02-19 04:06:41 +00:00
},
},
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
name: "Stddev_Float",
q: `SELECT stddev(value) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-02T00:00:00Z' GROUP BY time(10s), host fill(none)`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Float,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 0 * Second, Value: 20},
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 11 * Second, Value: 3},
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 31 * Second, Value: 100},
}},
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 5 * Second, Value: 10},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 50 * Second, Value: 1},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 51 * Second, Value: 2},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 52 * Second, Value: 3},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 53 * Second, Value: 4},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 53 * Second, Value: 5},
}},
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 9 * Second, Value: 19},
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 10 * Second, Value: 2},
}},
},
points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 0 * Second, Value: 0.7071067811865476}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 10 * Second, Value: 0.7071067811865476}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 30 * Second, Nil: true}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=B"), Time: 0 * Second, Nil: true}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=B"), Time: 50 * Second, Value: 1.5811388300841898}},
Add binary expr tests to influxql package No boolean operator tests because the parser doesn't currently allow it. I am currently keeping the code that performs this for now until we decide whether to allow boolean operators inside of a select clause. It would be easy to have the new query engine do something like this: SELECT mean(value) < 10 FROM cpu GROUP BY time(1m) And then you would have it return true or false for each interval, but the same can be done through a where clause too.
2016-02-01 22:08:37 +00:00
},
},
Improve test coverage in influxql package
2016-02-08 22:26:36 +00:00
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
name: "Stddev_Integer",
q: `SELECT stddev(value) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-02T00:00:00Z' GROUP BY time(10s), host fill(none)`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Integer,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&IntegerIterator{Points: []query.IntegerPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 0 * Second, Value: 20},
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 11 * Second, Value: 3},
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 31 * Second, Value: 100},
}},
&IntegerIterator{Points: []query.IntegerPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 5 * Second, Value: 10},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 50 * Second, Value: 1},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 51 * Second, Value: 2},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 52 * Second, Value: 3},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 53 * Second, Value: 4},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 53 * Second, Value: 5},
}},
&IntegerIterator{Points: []query.IntegerPoint{
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 9 * Second, Value: 19},
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 10 * Second, Value: 2},
}},
},
points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 0 * Second, Value: 0.7071067811865476}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 10 * Second, Value: 0.7071067811865476}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 30 * Second, Nil: true}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=B"), Time: 0 * Second, Nil: true}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=B"), Time: 50 * Second, Value: 1.5811388300841898}},
Improve test coverage in influxql package
2016-02-08 22:26:36 +00:00
},
},
Add binary expr tests to influxql package No boolean operator tests because the parser doesn't currently allow it. I am currently keeping the code that performs this for now until we decide whether to allow boolean operators inside of a select clause. It would be easy to have the new query engine do something like this: SELECT mean(value) < 10 FROM cpu GROUP BY time(1m) And then you would have it return true or false for each interval, but the same can be done through a where clause too.
2016-02-01 22:08:37 +00:00
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
name: "Spread_Float",
q: `SELECT spread(value) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-02T00:00:00Z' GROUP BY time(10s), host fill(none)`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Float,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 0 * Second, Value: 20},
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 11 * Second, Value: 3},
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 31 * Second, Value: 100},
}},
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 5 * Second, Value: 10},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 50 * Second, Value: 1},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 51 * Second, Value: 2},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 52 * Second, Value: 3},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 53 * Second, Value: 4},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 53 * Second, Value: 5},
}},
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 9 * Second, Value: 19},
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 10 * Second, Value: 2},
}},
},
points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 0 * Second, Value: 1}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 10 * Second, Value: 1}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 30 * Second, Value: 0}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=B"), Time: 0 * Second, Value: 0}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=B"), Time: 50 * Second, Value: 4}},
Support integer literals in the query language Numbers in the query without any decimal will now be emitted as integers instead and be parsed as an IntegerLiteral. This ensures we keep the original context that a query was issued with and allows us to act more similar to how programming languages are typically structured when it comes to floats and ints. This adds functionality for dealing with integers promoting to floats in the various different places where math are used. Fixes #5744 and #5629.
2016-02-19 04:06:41 +00:00
},
},
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
name: "Spread_Integer",
q: `SELECT spread(value) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-02T00:00:00Z' GROUP BY time(10s), host fill(none)`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Integer,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&IntegerIterator{Points: []query.IntegerPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 0 * Second, Value: 20},
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 11 * Second, Value: 3},
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 31 * Second, Value: 100},
}},
&IntegerIterator{Points: []query.IntegerPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 5 * Second, Value: 10},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 50 * Second, Value: 1},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 51 * Second, Value: 2},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 52 * Second, Value: 3},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 53 * Second, Value: 4},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 53 * Second, Value: 5},
}},
&IntegerIterator{Points: []query.IntegerPoint{
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 9 * Second, Value: 19},
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 10 * Second, Value: 2},
}},
},
points: [][]query.Point{
{&query.IntegerPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 0 * Second, Value: 1}},
{&query.IntegerPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 10 * Second, Value: 1}},
{&query.IntegerPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 30 * Second, Value: 0}},
{&query.IntegerPoint{Name: "cpu", Tags: ParseTags("host=B"), Time: 0 * Second, Value: 0}},
{&query.IntegerPoint{Name: "cpu", Tags: ParseTags("host=B"), Time: 50 * Second, Value: 4}},
Add binary expr tests to influxql package No boolean operator tests because the parser doesn't currently allow it. I am currently keeping the code that performs this for now until we decide whether to allow boolean operators inside of a select clause. It would be easy to have the new query engine do something like this: SELECT mean(value) < 10 FROM cpu GROUP BY time(1m) And then you would have it return true or false for each interval, but the same can be done through a where clause too.
2016-02-01 22:08:37 +00:00
},
},
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
name: "Percentile_Float",
q: `SELECT percentile(value, 90) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-02T00:00:00Z' GROUP BY time(10s), host fill(none)`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Float,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 0 * Second, Value: 20},
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 11 * Second, Value: 3},
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 31 * Second, Value: 100},
}},
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 5 * Second, Value: 10},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 50 * Second, Value: 10},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 51 * Second, Value: 9},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 52 * Second, Value: 8},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 53 * Second, Value: 7},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 54 * Second, Value: 6},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 55 * Second, Value: 5},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 56 * Second, Value: 4},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 57 * Second, Value: 3},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 58 * Second, Value: 2},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 59 * Second, Value: 1},
}},
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 9 * Second, Value: 19},
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 10 * Second, Value: 2},
}},
},
points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 0 * Second, Value: 20}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 10 * Second, Value: 3}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 30 * Second, Value: 100}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=B"), Time: 0 * Second, Value: 10}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=B"), Time: 50 * Second, Value: 9}},
Support integer literals in the query language Numbers in the query without any decimal will now be emitted as integers instead and be parsed as an IntegerLiteral. This ensures we keep the original context that a query was issued with and allows us to act more similar to how programming languages are typically structured when it comes to floats and ints. This adds functionality for dealing with integers promoting to floats in the various different places where math are used. Fixes #5744 and #5629.
2016-02-19 04:06:41 +00:00
},
},
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
name: "Percentile_Integer",
q: `SELECT percentile(value, 90) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-02T00:00:00Z' GROUP BY time(10s), host fill(none)`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Integer,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&IntegerIterator{Points: []query.IntegerPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 0 * Second, Value: 20},
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 11 * Second, Value: 3},
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 31 * Second, Value: 100},
}},
&IntegerIterator{Points: []query.IntegerPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 5 * Second, Value: 10},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 50 * Second, Value: 10},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 51 * Second, Value: 9},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 52 * Second, Value: 8},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 53 * Second, Value: 7},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 54 * Second, Value: 6},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 55 * Second, Value: 5},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 56 * Second, Value: 4},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 57 * Second, Value: 3},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 58 * Second, Value: 2},
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 59 * Second, Value: 1},
}},
&IntegerIterator{Points: []query.IntegerPoint{
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 9 * Second, Value: 19},
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 10 * Second, Value: 2},
}},
},
points: [][]query.Point{
{&query.IntegerPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 0 * Second, Value: 20}},
{&query.IntegerPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 10 * Second, Value: 3}},
{&query.IntegerPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 30 * Second, Value: 100}},
{&query.IntegerPoint{Name: "cpu", Tags: ParseTags("host=B"), Time: 0 * Second, Value: 10}},
{&query.IntegerPoint{Name: "cpu", Tags: ParseTags("host=B"), Time: 50 * Second, Value: 9}},
Add binary expr tests to influxql package No boolean operator tests because the parser doesn't currently allow it. I am currently keeping the code that performs this for now until we decide whether to allow boolean operators inside of a select clause. It would be easy to have the new query engine do something like this: SELECT mean(value) < 10 FROM cpu GROUP BY time(1m) And then you would have it return true or false for each interval, but the same can be done through a where clause too.
2016-02-01 22:08:37 +00:00
},
},
Improve test coverage in influxql package
2016-02-08 22:26:36 +00:00
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
name: "Sample_Float",
q: `SELECT sample(value, 2) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-02T00:00:00Z' GROUP BY time(10s), host fill(none)`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Float,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 0 * Second, Value: 20},
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 5 * Second, Value: 10},
}},
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Tags: ParseTags("region=east,host=B"), Time: 10 * Second, Value: 19},
{Name: "cpu", Tags: ParseTags("region=east,host=B"), Time: 15 * Second, Value: 2},
}},
},
points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 0 * Second, Value: 20}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 5 * Second, Value: 10}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=B"), Time: 10 * Second, Value: 19}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=B"), Time: 15 * Second, Value: 2}},
Improve test coverage in influxql package
2016-02-08 22:26:36 +00:00
},
},
Add binary expr tests to influxql package No boolean operator tests because the parser doesn't currently allow it. I am currently keeping the code that performs this for now until we decide whether to allow boolean operators inside of a select clause. It would be easy to have the new query engine do something like this: SELECT mean(value) < 10 FROM cpu GROUP BY time(1m) And then you would have it return true or false for each interval, but the same can be done through a where clause too.
2016-02-01 22:08:37 +00:00
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
name: "Sample_Integer",
q: `SELECT sample(value, 2) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-02T00:00:00Z' GROUP BY time(10s), host fill(none)`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Integer,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&IntegerIterator{Points: []query.IntegerPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 0 * Second, Value: 20},
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 5 * Second, Value: 10},
}},
&IntegerIterator{Points: []query.IntegerPoint{
{Name: "cpu", Tags: ParseTags("region=east,host=B"), Time: 10 * Second, Value: 19},
{Name: "cpu", Tags: ParseTags("region=east,host=B"), Time: 15 * Second, Value: 2},
}},
},
points: [][]query.Point{
{&query.IntegerPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 0 * Second, Value: 20}},
{&query.IntegerPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 5 * Second, Value: 10}},
{&query.IntegerPoint{Name: "cpu", Tags: ParseTags("host=B"), Time: 10 * Second, Value: 19}},
{&query.IntegerPoint{Name: "cpu", Tags: ParseTags("host=B"), Time: 15 * Second, Value: 2}},
Support integer literals in the query language Numbers in the query without any decimal will now be emitted as integers instead and be parsed as an IntegerLiteral. This ensures we keep the original context that a query was issued with and allows us to act more similar to how programming languages are typically structured when it comes to floats and ints. This adds functionality for dealing with integers promoting to floats in the various different places where math are used. Fixes #5744 and #5629.
2016-02-19 04:06:41 +00:00
},
},
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
name: "Sample_String",
q: `SELECT sample(value, 2) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-02T00:00:00Z' GROUP BY time(10s), host fill(none)`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.String,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&StringIterator{Points: []query.StringPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 0 * Second, Value: "a"},
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 5 * Second, Value: "b"},
}},
&StringIterator{Points: []query.StringPoint{
{Name: "cpu", Tags: ParseTags("region=east,host=B"), Time: 10 * Second, Value: "c"},
{Name: "cpu", Tags: ParseTags("region=east,host=B"), Time: 15 * Second, Value: "d"},
}},
},
points: [][]query.Point{
{&query.StringPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 0 * Second, Value: "a"}},
{&query.StringPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 5 * Second, Value: "b"}},
{&query.StringPoint{Name: "cpu", Tags: ParseTags("host=B"), Time: 10 * Second, Value: "c"}},
{&query.StringPoint{Name: "cpu", Tags: ParseTags("host=B"), Time: 15 * Second, Value: "d"}},
Add binary expr tests to influxql package No boolean operator tests because the parser doesn't currently allow it. I am currently keeping the code that performs this for now until we decide whether to allow boolean operators inside of a select clause. It would be easy to have the new query engine do something like this: SELECT mean(value) < 10 FROM cpu GROUP BY time(1m) And then you would have it return true or false for each interval, but the same can be done through a where clause too.
2016-02-01 22:08:37 +00:00
},
},
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
name: "Sample_Boolean",
q: `SELECT sample(value, 2) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-02T00:00:00Z' GROUP BY time(10s), host fill(none)`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Boolean,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&BooleanIterator{Points: []query.BooleanPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 0 * Second, Value: true},
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 5 * Second, Value: false},
}},
&BooleanIterator{Points: []query.BooleanPoint{
{Name: "cpu", Tags: ParseTags("region=east,host=B"), Time: 10 * Second, Value: false},
{Name: "cpu", Tags: ParseTags("region=east,host=B"), Time: 15 * Second, Value: true},
}},
},
points: [][]query.Point{
{&query.BooleanPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 0 * Second, Value: true}},
{&query.BooleanPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 5 * Second, Value: false}},
{&query.BooleanPoint{Name: "cpu", Tags: ParseTags("host=B"), Time: 10 * Second, Value: false}},
{&query.BooleanPoint{Name: "cpu", Tags: ParseTags("host=B"), Time: 15 * Second, Value: true}},
Support integer literals in the query language Numbers in the query without any decimal will now be emitted as integers instead and be parsed as an IntegerLiteral. This ensures we keep the original context that a query was issued with and allows us to act more similar to how programming languages are typically structured when it comes to floats and ints. This adds functionality for dealing with integers promoting to floats in the various different places where math are used. Fixes #5744 and #5629.
2016-02-19 04:06:41 +00:00
},
},
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
//{
// name: "Raw",
// q: `SELECT v1::float, v2::float FROM cpu`,
// itrs: []query.Iterator{
// &FloatIterator{Points: []query.FloatPoint{
// {Time: 0, Aux: []interface{}{float64(1), nil}},
// {Time: 1, Aux: []interface{}{nil, float64(2)}},
// {Time: 5, Aux: []interface{}{float64(3), float64(4)}},
// }},
// },
// points: [][]query.Point{
// {
// &query.FloatPoint{Time: 0, Value: 1},
// &query.FloatPoint{Time: 0, Nil: true},
// },
// {
// &query.FloatPoint{Time: 1, Nil: true},
// &query.FloatPoint{Time: 1, Value: 2},
// },
// {
// &query.FloatPoint{Time: 5, Value: 3},
// &query.FloatPoint{Time: 5, Value: 4},
// },
// },
//},
Improve test coverage in influxql package
2016-02-08 22:26:36 +00:00
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
name: "ParenExpr_Min",
q: `SELECT (min(value)) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-02T00:00:00Z' GROUP BY time(10s), host fill(none)`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Float,
expr: `min(value::float)`,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 0 * Second, Value: 20},
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 11 * Second, Value: 3},
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 31 * Second, Value: 100},
}},
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 5 * Second, Value: 10},
}},
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 9 * Second, Value: 19},
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 10 * Second, Value: 2},
}},
},
points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 0 * Second, Value: 19, Aggregated: 2}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 10 * Second, Value: 2, Aggregated: 2}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 30 * Second, Value: 100, Aggregated: 1}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=B"), Time: 0 * Second, Value: 10, Aggregated: 1}},
Improve test coverage in influxql package
2016-02-08 22:26:36 +00:00
},
},
Add binary expr tests to influxql package No boolean operator tests because the parser doesn't currently allow it. I am currently keeping the code that performs this for now until we decide whether to allow boolean operators inside of a select clause. It would be easy to have the new query engine do something like this: SELECT mean(value) < 10 FROM cpu GROUP BY time(1m) And then you would have it return true or false for each interval, but the same can be done through a where clause too.
2016-02-01 22:08:37 +00:00
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
name: "ParenExpr_Distinct",
q: `SELECT (distinct(value)) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-02T00:00:00Z' GROUP BY time(10s), host fill(none)`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Float,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 0 * Second, Value: 20},
{Name: "cpu", Tags: ParseTags("region=west,host=A"), Time: 1 * Second, Value: 19},
}},
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Tags: ParseTags("region=west,host=B"), Time: 5 * Second, Value: 10},
}},
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 9 * Second, Value: 19},
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 10 * Second, Value: 2},
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 11 * Second, Value: 2},
{Name: "cpu", Tags: ParseTags("region=east,host=A"), Time: 12 * Second, Value: 2},
}},
},
points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 0 * Second, Value: 20}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 0 * Second, Value: 19}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=A"), Time: 10 * Second, Value: 2}},
{&query.FloatPoint{Name: "cpu", Tags: ParseTags("host=B"), Time: 0 * Second, Value: 10}},
Support integer literals in the query language Numbers in the query without any decimal will now be emitted as integers instead and be parsed as an IntegerLiteral. This ensures we keep the original context that a query was issued with and allows us to act more similar to how programming languages are typically structured when it comes to floats and ints. This adds functionality for dealing with integers promoting to floats in the various different places where math are used. Fixes #5744 and #5629.
2016-02-19 04:06:41 +00:00
},
},
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
name: "Derivative_Float",
q: `SELECT derivative(value, 1s) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-01T00:00:16Z'`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Float,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Time: 0 * Second, Value: 20},
{Name: "cpu", Time: 4 * Second, Value: 10},
{Name: "cpu", Time: 8 * Second, Value: 19},
{Name: "cpu", Time: 12 * Second, Value: 3},
}},
},
points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Time: 4 * Second, Value: -2.5}},
{&query.FloatPoint{Name: "cpu", Time: 8 * Second, Value: 2.25}},
{&query.FloatPoint{Name: "cpu", Time: 12 * Second, Value: -4}},
Add binary expr tests to influxql package No boolean operator tests because the parser doesn't currently allow it. I am currently keeping the code that performs this for now until we decide whether to allow boolean operators inside of a select clause. It would be easy to have the new query engine do something like this: SELECT mean(value) < 10 FROM cpu GROUP BY time(1m) And then you would have it return true or false for each interval, but the same can be done through a where clause too.
2016-02-01 22:08:37 +00:00
},
},
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
name: "Derivative_Integer",
q: `SELECT derivative(value, 1s) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-01T00:00:16Z'`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Integer,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&IntegerIterator{Points: []query.IntegerPoint{
{Name: "cpu", Time: 0 * Second, Value: 20},
{Name: "cpu", Time: 4 * Second, Value: 10},
{Name: "cpu", Time: 8 * Second, Value: 19},
{Name: "cpu", Time: 12 * Second, Value: 3},
}},
},
points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Time: 4 * Second, Value: -2.5}},
{&query.FloatPoint{Name: "cpu", Time: 8 * Second, Value: 2.25}},
{&query.FloatPoint{Name: "cpu", Time: 12 * Second, Value: -4}},
Support integer literals in the query language Numbers in the query without any decimal will now be emitted as integers instead and be parsed as an IntegerLiteral. This ensures we keep the original context that a query was issued with and allows us to act more similar to how programming languages are typically structured when it comes to floats and ints. This adds functionality for dealing with integers promoting to floats in the various different places where math are used. Fixes #5744 and #5629.
2016-02-19 04:06:41 +00:00
},
},
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
name: "Derivative_Desc_Float",
q: `SELECT derivative(value, 1s) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-01T00:00:16Z' ORDER BY desc`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Float,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Time: 12 * Second, Value: 3},
{Name: "cpu", Time: 8 * Second, Value: 19},
{Name: "cpu", Time: 4 * Second, Value: 10},
{Name: "cpu", Time: 0 * Second, Value: 20},
}},
},
points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Time: 8 * Second, Value: 4}},
{&query.FloatPoint{Name: "cpu", Time: 4 * Second, Value: -2.25}},
{&query.FloatPoint{Name: "cpu", Time: 0 * Second, Value: 2.5}},
Add binary expr tests to influxql package No boolean operator tests because the parser doesn't currently allow it. I am currently keeping the code that performs this for now until we decide whether to allow boolean operators inside of a select clause. It would be easy to have the new query engine do something like this: SELECT mean(value) < 10 FROM cpu GROUP BY time(1m) And then you would have it return true or false for each interval, but the same can be done through a where clause too.
2016-02-01 22:08:37 +00:00
},
},
Improve test coverage in influxql package
2016-02-08 22:26:36 +00:00
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
name: "Derivative_Desc_Integer",
q: `SELECT derivative(value, 1s) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-01T00:00:16Z' ORDER BY desc`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Integer,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&IntegerIterator{Points: []query.IntegerPoint{
{Name: "cpu", Time: 12 * Second, Value: 3},
{Name: "cpu", Time: 8 * Second, Value: 19},
{Name: "cpu", Time: 4 * Second, Value: 10},
{Name: "cpu", Time: 0 * Second, Value: 20},
}},
},
points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Time: 8 * Second, Value: 4}},
{&query.FloatPoint{Name: "cpu", Time: 4 * Second, Value: -2.25}},
{&query.FloatPoint{Name: "cpu", Time: 0 * Second, Value: 2.5}},
Improve test coverage in influxql package
2016-02-08 22:26:36 +00:00
},
},
Add binary expr tests to influxql package No boolean operator tests because the parser doesn't currently allow it. I am currently keeping the code that performs this for now until we decide whether to allow boolean operators inside of a select clause. It would be easy to have the new query engine do something like this: SELECT mean(value) < 10 FROM cpu GROUP BY time(1m) And then you would have it return true or false for each interval, but the same can be done through a where clause too.
2016-02-01 22:08:37 +00:00
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
name: "Derivative_Duplicate_Float",
q: `SELECT derivative(value, 1s) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-01T00:00:16Z'`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Float,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Time: 0 * Second, Value: 20},
{Name: "cpu", Time: 0 * Second, Value: 19},
{Name: "cpu", Time: 4 * Second, Value: 10},
{Name: "cpu", Time: 4 * Second, Value: 3},
}},
},
points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Time: 4 * Second, Value: -2.5}},
},
},
{
name: "Derivative_Duplicate_Integer",
q: `SELECT derivative(value, 1s) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-01T00:00:16Z'`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Integer,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&IntegerIterator{Points: []query.IntegerPoint{
{Name: "cpu", Time: 0 * Second, Value: 20},
{Name: "cpu", Time: 0 * Second, Value: 19},
{Name: "cpu", Time: 4 * Second, Value: 10},
{Name: "cpu", Time: 4 * Second, Value: 3},
}},
},
points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Time: 4 * Second, Value: -2.5}},
},
},
{
name: "Difference_Float",
q: `SELECT difference(value) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-01T00:00:16Z'`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Float,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Time: 0 * Second, Value: 20},
{Name: "cpu", Time: 4 * Second, Value: 10},
{Name: "cpu", Time: 8 * Second, Value: 19},
{Name: "cpu", Time: 12 * Second, Value: 3},
}},
},
points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Time: 4 * Second, Value: -10}},
{&query.FloatPoint{Name: "cpu", Time: 8 * Second, Value: 9}},
{&query.FloatPoint{Name: "cpu", Time: 12 * Second, Value: -16}},
},
},
{
name: "Difference_Integer",
q: `SELECT difference(value) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-01T00:00:16Z'`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Integer,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&IntegerIterator{Points: []query.IntegerPoint{
{Name: "cpu", Time: 0 * Second, Value: 20},
{Name: "cpu", Time: 4 * Second, Value: 10},
{Name: "cpu", Time: 8 * Second, Value: 19},
{Name: "cpu", Time: 12 * Second, Value: 3},
}},
},
points: [][]query.Point{
{&query.IntegerPoint{Name: "cpu", Time: 4 * Second, Value: -10}},
{&query.IntegerPoint{Name: "cpu", Time: 8 * Second, Value: 9}},
{&query.IntegerPoint{Name: "cpu", Time: 12 * Second, Value: -16}},
},
},
{
name: "Difference_Duplicate_Float",
q: `SELECT difference(value) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-01T00:00:16Z'`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Float,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Time: 0 * Second, Value: 20},
{Name: "cpu", Time: 0 * Second, Value: 19},
{Name: "cpu", Time: 4 * Second, Value: 10},
{Name: "cpu", Time: 4 * Second, Value: 3},
}},
},
points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Time: 4 * Second, Value: -10}},
},
},
{
name: "Difference_Duplicate_Integer",
q: `SELECT difference(value) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-01T00:00:16Z'`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Integer,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&IntegerIterator{Points: []query.IntegerPoint{
{Name: "cpu", Time: 0 * Second, Value: 20},
{Name: "cpu", Time: 0 * Second, Value: 19},
{Name: "cpu", Time: 4 * Second, Value: 10},
{Name: "cpu", Time: 4 * Second, Value: 3},
}},
},
points: [][]query.Point{
{&query.IntegerPoint{Name: "cpu", Time: 4 * Second, Value: -10}},
},
},
{
name: "Non_Negative_Difference_Float",
q: `SELECT non_negative_difference(value) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-01T00:00:16Z'`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Float,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Time: 0 * Second, Value: 20},
{Name: "cpu", Time: 4 * Second, Value: 10},
{Name: "cpu", Time: 8 * Second, Value: 29},
{Name: "cpu", Time: 12 * Second, Value: 3},
{Name: "cpu", Time: 16 * Second, Value: 39},
}},
},
points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Time: 8 * Second, Value: 19}},
{&query.FloatPoint{Name: "cpu", Time: 16 * Second, Value: 36}},
},
},
{
name: "Non_Negative_Difference_Integer",
q: `SELECT non_negative_difference(value) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-01T00:00:16Z'`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Integer,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&IntegerIterator{Points: []query.IntegerPoint{
{Name: "cpu", Time: 0 * Second, Value: 20},
{Name: "cpu", Time: 4 * Second, Value: 10},
{Name: "cpu", Time: 8 * Second, Value: 21},
{Name: "cpu", Time: 12 * Second, Value: 3},
}},
},
points: [][]query.Point{
{&query.IntegerPoint{Name: "cpu", Time: 8 * Second, Value: 11}},
},
},
{
name: "Non_Negative_Difference_Duplicate_Float",
q: `SELECT non_negative_difference(value) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-01T00:00:16Z'`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Float,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Time: 0 * Second, Value: 20},
{Name: "cpu", Time: 0 * Second, Value: 19},
{Name: "cpu", Time: 4 * Second, Value: 10},
{Name: "cpu", Time: 4 * Second, Value: 3},
{Name: "cpu", Time: 8 * Second, Value: 30},
{Name: "cpu", Time: 8 * Second, Value: 19},
{Name: "cpu", Time: 12 * Second, Value: 10},
{Name: "cpu", Time: 12 * Second, Value: 3},
{Name: "cpu", Time: 16 * Second, Value: 40},
{Name: "cpu", Time: 16 * Second, Value: 3},
}},
},
points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Time: 8 * Second, Value: 20}},
{&query.FloatPoint{Name: "cpu", Time: 16 * Second, Value: 30}},
},
},
{
name: "Non_Negative_Difference_Duplicate_Integer",
q: `SELECT non_negative_difference(value) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-01T00:00:16Z'`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Integer,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&IntegerIterator{Points: []query.IntegerPoint{
{Name: "cpu", Time: 0 * Second, Value: 20},
{Name: "cpu", Time: 0 * Second, Value: 19},
{Name: "cpu", Time: 4 * Second, Value: 10},
{Name: "cpu", Time: 4 * Second, Value: 3},
{Name: "cpu", Time: 8 * Second, Value: 30},
{Name: "cpu", Time: 8 * Second, Value: 19},
{Name: "cpu", Time: 12 * Second, Value: 10},
{Name: "cpu", Time: 12 * Second, Value: 3},
{Name: "cpu", Time: 16 * Second, Value: 40},
{Name: "cpu", Time: 16 * Second, Value: 3},
}},
},
points: [][]query.Point{
{&query.IntegerPoint{Name: "cpu", Time: 8 * Second, Value: 20}},
{&query.IntegerPoint{Name: "cpu", Time: 16 * Second, Value: 30}},
},
},
{
name: "Elapsed_Float",
q: `SELECT elapsed(value, 1s) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-01T00:00:16Z'`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Float,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Time: 0 * Second, Value: 20},
{Name: "cpu", Time: 4 * Second, Value: 10},
{Name: "cpu", Time: 8 * Second, Value: 19},
{Name: "cpu", Time: 11 * Second, Value: 3},
}},
},
points: [][]query.Point{
{&query.IntegerPoint{Name: "cpu", Time: 4 * Second, Value: 4}},
{&query.IntegerPoint{Name: "cpu", Time: 8 * Second, Value: 4}},
{&query.IntegerPoint{Name: "cpu", Time: 11 * Second, Value: 3}},
},
},
{
name: "Elapsed_Integer",
q: `SELECT elapsed(value, 1s) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-01T00:00:16Z'`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Integer,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&IntegerIterator{Points: []query.IntegerPoint{
{Name: "cpu", Time: 0 * Second, Value: 20},
{Name: "cpu", Time: 4 * Second, Value: 10},
{Name: "cpu", Time: 8 * Second, Value: 19},
{Name: "cpu", Time: 11 * Second, Value: 3},
}},
},
points: [][]query.Point{
{&query.IntegerPoint{Name: "cpu", Time: 4 * Second, Value: 4}},
{&query.IntegerPoint{Name: "cpu", Time: 8 * Second, Value: 4}},
{&query.IntegerPoint{Name: "cpu", Time: 11 * Second, Value: 3}},
},
},
{
name: "Elapsed_String",
q: `SELECT elapsed(value, 1s) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-01T00:00:16Z'`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.String,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&StringIterator{Points: []query.StringPoint{
{Name: "cpu", Time: 0 * Second, Value: "a"},
{Name: "cpu", Time: 4 * Second, Value: "b"},
{Name: "cpu", Time: 8 * Second, Value: "c"},
{Name: "cpu", Time: 11 * Second, Value: "d"},
}},
},
points: [][]query.Point{
{&query.IntegerPoint{Name: "cpu", Time: 4 * Second, Value: 4}},
{&query.IntegerPoint{Name: "cpu", Time: 8 * Second, Value: 4}},
{&query.IntegerPoint{Name: "cpu", Time: 11 * Second, Value: 3}},
},
},
{
name: "Elapsed_Boolean",
q: `SELECT elapsed(value, 1s) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-01T00:00:16Z'`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Boolean,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&BooleanIterator{Points: []query.BooleanPoint{
{Name: "cpu", Time: 0 * Second, Value: true},
{Name: "cpu", Time: 4 * Second, Value: false},
{Name: "cpu", Time: 8 * Second, Value: false},
{Name: "cpu", Time: 11 * Second, Value: true},
}},
},
points: [][]query.Point{
{&query.IntegerPoint{Name: "cpu", Time: 4 * Second, Value: 4}},
{&query.IntegerPoint{Name: "cpu", Time: 8 * Second, Value: 4}},
{&query.IntegerPoint{Name: "cpu", Time: 11 * Second, Value: 3}},
},
},
{
name: "Integral_Float",
q: `SELECT integral(value) FROM cpu`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Float,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Time: 10 * Second, Value: 20},
{Name: "cpu", Time: 15 * Second, Value: 10},
{Name: "cpu", Time: 20 * Second, Value: 0},
{Name: "cpu", Time: 30 * Second, Value: -10},
}},
},
points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Time: 0, Value: 50}},
},
},
{
name: "Integral_Duplicate_Float",
q: `SELECT integral(value) FROM cpu`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Float,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Time: 0 * Second, Value: 20},
{Name: "cpu", Time: 5 * Second, Value: 10},
{Name: "cpu", Time: 5 * Second, Value: 30},
{Name: "cpu", Time: 10 * Second, Value: 40},
}},
},
points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Time: 0, Value: 250}},
},
},
{
name: "Integral_Float_GroupByTime",
q: `SELECT integral(value) FROM cpu WHERE time > 0s AND time < 60s GROUP BY time(20s)`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Float,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Time: 10 * Second, Value: 20},
{Name: "cpu", Time: 15 * Second, Value: 10},
{Name: "cpu", Time: 20 * Second, Value: 0},
{Name: "cpu", Time: 30 * Second, Value: -10},
}},
},
points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Time: 0, Value: 100}},
{&query.FloatPoint{Name: "cpu", Time: 20 * Second, Value: -50}},
},
},
{
name: "Integral_Float_InterpolateGroupByTime",
q: `SELECT integral(value) FROM cpu WHERE time > 0s AND time < 60s GROUP BY time(20s)`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Float,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Time: 10 * Second, Value: 20},
{Name: "cpu", Time: 15 * Second, Value: 10},
{Name: "cpu", Time: 25 * Second, Value: 0},
{Name: "cpu", Time: 30 * Second, Value: -10},
}},
},
points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Time: 0, Value: 112.5}},
{&query.FloatPoint{Name: "cpu", Time: 20 * Second, Value: -12.5}},
},
},
{
name: "Integral_Integer",
q: `SELECT integral(value) FROM cpu`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Integer,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&IntegerIterator{Points: []query.IntegerPoint{
{Name: "cpu", Time: 0 * Second, Value: 20},
{Name: "cpu", Time: 5 * Second, Value: 10},
{Name: "cpu", Time: 10 * Second, Value: 0},
{Name: "cpu", Time: 20 * Second, Value: -10},
}},
},
points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Time: 0, Value: 50}},
},
},
{
name: "Integral_Duplicate_Integer",
q: `SELECT integral(value, 2s) FROM cpu`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Integer,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&IntegerIterator{Points: []query.IntegerPoint{
{Name: "cpu", Time: 0 * Second, Value: 20},
{Name: "cpu", Time: 5 * Second, Value: 10},
{Name: "cpu", Time: 5 * Second, Value: 30},
{Name: "cpu", Time: 10 * Second, Value: 40},
}},
},
points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Time: 0, Value: 125}},
},
},
{
name: "MovingAverage_Float",
q: `SELECT moving_average(value, 2) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-01T00:00:16Z'`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Float,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Time: 0 * Second, Value: 20},
{Name: "cpu", Time: 4 * Second, Value: 10},
{Name: "cpu", Time: 8 * Second, Value: 19},
{Name: "cpu", Time: 12 * Second, Value: 3},
}},
},
points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Time: 4 * Second, Value: 15, Aggregated: 2}},
{&query.FloatPoint{Name: "cpu", Time: 8 * Second, Value: 14.5, Aggregated: 2}},
{&query.FloatPoint{Name: "cpu", Time: 12 * Second, Value: 11, Aggregated: 2}},
},
},
{
name: "MovingAverage_Integer",
q: `SELECT moving_average(value, 2) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-01T00:00:16Z'`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Integer,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&IntegerIterator{Points: []query.IntegerPoint{
{Name: "cpu", Time: 0 * Second, Value: 20},
{Name: "cpu", Time: 4 * Second, Value: 10},
{Name: "cpu", Time: 8 * Second, Value: 19},
{Name: "cpu", Time: 12 * Second, Value: 3},
}},
},
points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Time: 4 * Second, Value: 15, Aggregated: 2}},
{&query.FloatPoint{Name: "cpu", Time: 8 * Second, Value: 14.5, Aggregated: 2}},
{&query.FloatPoint{Name: "cpu", Time: 12 * Second, Value: 11, Aggregated: 2}},
},
},
{
name: "CumulativeSum_Float",
q: `SELECT cumulative_sum(value) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-01T00:00:16Z'`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Float,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Time: 0 * Second, Value: 20},
{Name: "cpu", Time: 4 * Second, Value: 10},
{Name: "cpu", Time: 8 * Second, Value: 19},
{Name: "cpu", Time: 12 * Second, Value: 3},
}},
},
points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Time: 0 * Second, Value: 20}},
{&query.FloatPoint{Name: "cpu", Time: 4 * Second, Value: 30}},
{&query.FloatPoint{Name: "cpu", Time: 8 * Second, Value: 49}},
{&query.FloatPoint{Name: "cpu", Time: 12 * Second, Value: 52}},
},
},
{
name: "CumulativeSum_Integer",
q: `SELECT cumulative_sum(value) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-01T00:00:16Z'`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Integer,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&IntegerIterator{Points: []query.IntegerPoint{
{Name: "cpu", Time: 0 * Second, Value: 20},
{Name: "cpu", Time: 4 * Second, Value: 10},
{Name: "cpu", Time: 8 * Second, Value: 19},
{Name: "cpu", Time: 12 * Second, Value: 3},
}},
},
points: [][]query.Point{
{&query.IntegerPoint{Name: "cpu", Time: 0 * Second, Value: 20}},
{&query.IntegerPoint{Name: "cpu", Time: 4 * Second, Value: 30}},
{&query.IntegerPoint{Name: "cpu", Time: 8 * Second, Value: 49}},
{&query.IntegerPoint{Name: "cpu", Time: 12 * Second, Value: 52}},
},
},
{
name: "CumulativeSum_Duplicate_Float",
q: `SELECT cumulative_sum(value) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-01T00:00:16Z'`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Float,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Time: 0 * Second, Value: 20},
{Name: "cpu", Time: 0 * Second, Value: 19},
{Name: "cpu", Time: 4 * Second, Value: 10},
{Name: "cpu", Time: 4 * Second, Value: 3},
}},
},
points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Time: 0 * Second, Value: 20}},
{&query.FloatPoint{Name: "cpu", Time: 0 * Second, Value: 39}},
{&query.FloatPoint{Name: "cpu", Time: 4 * Second, Value: 49}},
{&query.FloatPoint{Name: "cpu", Time: 4 * Second, Value: 52}},
},
},
{
name: "CumulativeSum_Duplicate_Integer",
q: `SELECT cumulative_sum(value) FROM cpu WHERE time >= '1970-01-01T00:00:00Z' AND time < '1970-01-01T00:00:16Z'`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Integer,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&IntegerIterator{Points: []query.IntegerPoint{
{Name: "cpu", Time: 0 * Second, Value: 20},
{Name: "cpu", Time: 0 * Second, Value: 19},
{Name: "cpu", Time: 4 * Second, Value: 10},
{Name: "cpu", Time: 4 * Second, Value: 3},
}},
},
points: [][]query.Point{
{&query.IntegerPoint{Name: "cpu", Time: 0 * Second, Value: 20}},
{&query.IntegerPoint{Name: "cpu", Time: 0 * Second, Value: 39}},
{&query.IntegerPoint{Name: "cpu", Time: 4 * Second, Value: 49}},
{&query.IntegerPoint{Name: "cpu", Time: 4 * Second, Value: 52}},
},
},
{
name: "HoltWinters_GroupBy_Agg",
q: `SELECT holt_winters(mean(value), 2, 2) FROM cpu WHERE time >= '1970-01-01T00:00:10Z' AND time < '1970-01-01T00:00:20Z' GROUP BY time(2s)`,
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
typ: influxql.Float,
expr: `mean(value::float)`,
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
itrs: []query.Iterator{
&FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Time: 10 * Second, Value: 4},
{Name: "cpu", Time: 11 * Second, Value: 6},
{Name: "cpu", Time: 12 * Second, Value: 9},
{Name: "cpu", Time: 13 * Second, Value: 11},
{Name: "cpu", Time: 14 * Second, Value: 5},
{Name: "cpu", Time: 15 * Second, Value: 7},
{Name: "cpu", Time: 16 * Second, Value: 10},
{Name: "cpu", Time: 17 * Second, Value: 12},
{Name: "cpu", Time: 18 * Second, Value: 6},
{Name: "cpu", Time: 19 * Second, Value: 8},
}},
},
points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Time: 20 * Second, Value: 11.960623419918432}},
{&query.FloatPoint{Name: "cpu", Time: 22 * Second, Value: 7.953140268154609}},
},
},
} {
t.Run(tt.name, func(t *testing.T) {
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
shardMapper := ShardMapper{
MapShardsFn: func(sources influxql.Sources, _ influxql.TimeRange) query.ShardGroup {
return &ShardGroup{
Fields: map[string]influxql.DataType{
"value": tt.typ,
},
Dimensions: []string{"host", "region"},
CreateIteratorFn: func(m *influxql.Measurement, opt query.IteratorOptions) (query.Iterator, error) {
if m.Name != "cpu" {
t.Fatalf("unexpected source: %s", m.Name)
}
if tt.expr != "" && !reflect.DeepEqual(opt.Expr, MustParseExpr(tt.expr)) {
t.Fatalf("unexpected expr: %s", spew.Sdump(opt.Expr))
}
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
itrs := tt.itrs
if _, ok := opt.Expr.(*influxql.Call); ok {
for i, itr := range itrs {
itr, err := query.NewCallIterator(itr, opt)
if err != nil {
return nil, err
}
itrs[i] = itr
}
}
return query.Iterators(itrs).Merge(opt)
},
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
}
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
},
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
}
Pass the select options to the shard mapper again
2017-08-23 20:54:07 +00:00
itrs, _, err := query.Select(MustParseSelectStatement(tt.q), &shardMapper, query.SelectOptions{})
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
if err != nil {
if tt.err == "" {
t.Fatal(err)
} else if have, want := err.Error(), tt.err; have != want {
t.Fatalf("unexpected error: have=%s want=%s", have, want)
}
} else if tt.err != "" {
t.Fatal("expected error")
} else if a, err := Iterators(itrs).ReadAll(); err != nil {
t.Fatalf("unexpected point: %s", err)
} else if diff := cmp.Diff(a, tt.points); diff != "" {
t.Fatalf("unexpected points:\n%s", diff)
}
})
}
}
// Ensure a SELECT binary expr queries can be executed as floats.
func TestSelect_BinaryExpr_Float(t *testing.T) {
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
shardMapper := ShardMapper{
MapShardsFn: func(sources influxql.Sources, _ influxql.TimeRange) query.ShardGroup {
return &ShardGroup{
Fields: map[string]influxql.DataType{
"value": influxql.Float,
},
CreateIteratorFn: func(m *influxql.Measurement, opt query.IteratorOptions) (query.Iterator, error) {
if m.Name != "cpu" {
t.Fatalf("unexpected source: %s", m.Name)
}
makeAuxFields := func(value float64) []interface{} {
aux := make([]interface{}, len(opt.Aux))
for i := range aux {
aux[i] = value
}
return aux
}
return &FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Time: 0 * Second, Aux: makeAuxFields(20)},
{Name: "cpu", Time: 5 * Second, Aux: makeAuxFields(10)},
{Name: "cpu", Time: 9 * Second, Aux: makeAuxFields(19)},
}}, nil
},
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
}
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
},
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
}
for _, test := range []struct {
Name string
Statement string
Points [][]query.Point
}{
{
Name: "AdditionRHS_Number",
Support integer literals in the query language Numbers in the query without any decimal will now be emitted as integers instead and be parsed as an IntegerLiteral. This ensures we keep the original context that a query was issued with and allows us to act more similar to how programming languages are typically structured when it comes to floats and ints. This adds functionality for dealing with integers promoting to floats in the various different places where math are used. Fixes #5744 and #5629.
2016-02-19 04:06:41 +00:00
Statement: `SELECT value + 2.0 FROM cpu`,
Separate the query engine into a separate package This change provides a clear separation between the query engine mechanics and the query language so that the language can be parsed and dealt with separate from the query engine itself.
2017-08-15 19:24:22 +00:00
Points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Time: 0 * Second, Value: 22}},
{&query.FloatPoint{Name: "cpu", Time: 5 * Second, Value: 12}},
{&query.FloatPoint{Name: "cpu", Time: 9 * Second, Value: 21}},
Add binary expr tests to influxql package No boolean operator tests because the parser doesn't currently allow it. I am currently keeping the code that performs this for now until we decide whether to allow boolean operators inside of a select clause. It would be easy to have the new query engine do something like this: SELECT mean(value) < 10 FROM cpu GROUP BY time(1m) And then you would have it return true or false for each interval, but the same can be done through a where clause too.
2016-02-01 22:08:37 +00:00
},
},
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
Name: "AdditionRHS_Integer",
Support integer literals in the query language Numbers in the query without any decimal will now be emitted as integers instead and be parsed as an IntegerLiteral. This ensures we keep the original context that a query was issued with and allows us to act more similar to how programming languages are typically structured when it comes to floats and ints. This adds functionality for dealing with integers promoting to floats in the various different places where math are used. Fixes #5744 and #5629.
2016-02-19 04:06:41 +00:00
Statement: `SELECT value + 2 FROM cpu`,
Separate the query engine into a separate package This change provides a clear separation between the query engine mechanics and the query language so that the language can be parsed and dealt with separate from the query engine itself.
2017-08-15 19:24:22 +00:00
Points: [][]query.Point{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
{&query.FloatPoint{Name: "cpu", Time: 0 * Second, Value: 22}},
{&query.FloatPoint{Name: "cpu", Time: 5 * Second, Value: 12}},
{&query.FloatPoint{Name: "cpu", Time: 9 * Second, Value: 21}},
Support integer literals in the query language Numbers in the query without any decimal will now be emitted as integers instead and be parsed as an IntegerLiteral. This ensures we keep the original context that a query was issued with and allows us to act more similar to how programming languages are typically structured when it comes to floats and ints. This adds functionality for dealing with integers promoting to floats in the various different places where math are used. Fixes #5744 and #5629.
2016-02-19 04:06:41 +00:00
},
},
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
Name: "AdditionLHS_Number",
Support integer literals in the query language Numbers in the query without any decimal will now be emitted as integers instead and be parsed as an IntegerLiteral. This ensures we keep the original context that a query was issued with and allows us to act more similar to how programming languages are typically structured when it comes to floats and ints. This adds functionality for dealing with integers promoting to floats in the various different places where math are used. Fixes #5744 and #5629.
2016-02-19 04:06:41 +00:00
Statement: `SELECT 2.0 + value FROM cpu`,
Separate the query engine into a separate package This change provides a clear separation between the query engine mechanics and the query language so that the language can be parsed and dealt with separate from the query engine itself.
2017-08-15 19:24:22 +00:00
Points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Time: 0 * Second, Value: 22}},
{&query.FloatPoint{Name: "cpu", Time: 5 * Second, Value: 12}},
{&query.FloatPoint{Name: "cpu", Time: 9 * Second, Value: 21}},
Add binary expr tests to influxql package No boolean operator tests because the parser doesn't currently allow it. I am currently keeping the code that performs this for now until we decide whether to allow boolean operators inside of a select clause. It would be easy to have the new query engine do something like this: SELECT mean(value) < 10 FROM cpu GROUP BY time(1m) And then you would have it return true or false for each interval, but the same can be done through a where clause too.
2016-02-01 22:08:37 +00:00
},
},
Support integer literals in the query language Numbers in the query without any decimal will now be emitted as integers instead and be parsed as an IntegerLiteral. This ensures we keep the original context that a query was issued with and allows us to act more similar to how programming languages are typically structured when it comes to floats and ints. This adds functionality for dealing with integers promoting to floats in the various different places where math are used. Fixes #5744 and #5629.
2016-02-19 04:06:41 +00:00
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
Name: "AdditionLHS_Integer",
Support integer literals in the query language Numbers in the query without any decimal will now be emitted as integers instead and be parsed as an IntegerLiteral. This ensures we keep the original context that a query was issued with and allows us to act more similar to how programming languages are typically structured when it comes to floats and ints. This adds functionality for dealing with integers promoting to floats in the various different places where math are used. Fixes #5744 and #5629.
2016-02-19 04:06:41 +00:00
Statement: `SELECT 2 + value FROM cpu`,
Separate the query engine into a separate package This change provides a clear separation between the query engine mechanics and the query language so that the language can be parsed and dealt with separate from the query engine itself.
2017-08-15 19:24:22 +00:00
Points: [][]query.Point{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
{&query.FloatPoint{Name: "cpu", Time: 0 * Second, Value: 22}},
{&query.FloatPoint{Name: "cpu", Time: 5 * Second, Value: 12}},
{&query.FloatPoint{Name: "cpu", Time: 9 * Second, Value: 21}},
Support integer literals in the query language Numbers in the query without any decimal will now be emitted as integers instead and be parsed as an IntegerLiteral. This ensures we keep the original context that a query was issued with and allows us to act more similar to how programming languages are typically structured when it comes to floats and ints. This adds functionality for dealing with integers promoting to floats in the various different places where math are used. Fixes #5744 and #5629.
2016-02-19 04:06:41 +00:00
},
},
Improve test coverage in influxql package
2016-02-08 22:26:36 +00:00
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
Name: "TwoVariableAddition",
Improve test coverage in influxql package
2016-02-08 22:26:36 +00:00
Statement: `SELECT value + value FROM cpu`,
Separate the query engine into a separate package This change provides a clear separation between the query engine mechanics and the query language so that the language can be parsed and dealt with separate from the query engine itself.
2017-08-15 19:24:22 +00:00
Points: [][]query.Point{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
{&query.FloatPoint{Name: "cpu", Time: 0 * Second, Value: 40}},
{&query.FloatPoint{Name: "cpu", Time: 5 * Second, Value: 20}},
{&query.FloatPoint{Name: "cpu", Time: 9 * Second, Value: 38}},
Improve test coverage in influxql package
2016-02-08 22:26:36 +00:00
},
},
Add binary expr tests to influxql package No boolean operator tests because the parser doesn't currently allow it. I am currently keeping the code that performs this for now until we decide whether to allow boolean operators inside of a select clause. It would be easy to have the new query engine do something like this: SELECT mean(value) < 10 FROM cpu GROUP BY time(1m) And then you would have it return true or false for each interval, but the same can be done through a where clause too.
2016-02-01 22:08:37 +00:00
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
Name: "MultiplicationRHS_Number",
Support integer literals in the query language Numbers in the query without any decimal will now be emitted as integers instead and be parsed as an IntegerLiteral. This ensures we keep the original context that a query was issued with and allows us to act more similar to how programming languages are typically structured when it comes to floats and ints. This adds functionality for dealing with integers promoting to floats in the various different places where math are used. Fixes #5744 and #5629.
2016-02-19 04:06:41 +00:00
Statement: `SELECT value * 2.0 FROM cpu`,
Separate the query engine into a separate package This change provides a clear separation between the query engine mechanics and the query language so that the language can be parsed and dealt with separate from the query engine itself.
2017-08-15 19:24:22 +00:00
Points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Time: 0 * Second, Value: 40}},
{&query.FloatPoint{Name: "cpu", Time: 5 * Second, Value: 20}},
{&query.FloatPoint{Name: "cpu", Time: 9 * Second, Value: 38}},
Add binary expr tests to influxql package No boolean operator tests because the parser doesn't currently allow it. I am currently keeping the code that performs this for now until we decide whether to allow boolean operators inside of a select clause. It would be easy to have the new query engine do something like this: SELECT mean(value) < 10 FROM cpu GROUP BY time(1m) And then you would have it return true or false for each interval, but the same can be done through a where clause too.
2016-02-01 22:08:37 +00:00
},
},
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
Name: "MultiplicationRHS_Integer",
Support integer literals in the query language Numbers in the query without any decimal will now be emitted as integers instead and be parsed as an IntegerLiteral. This ensures we keep the original context that a query was issued with and allows us to act more similar to how programming languages are typically structured when it comes to floats and ints. This adds functionality for dealing with integers promoting to floats in the various different places where math are used. Fixes #5744 and #5629.
2016-02-19 04:06:41 +00:00
Statement: `SELECT value * 2 FROM cpu`,
Separate the query engine into a separate package This change provides a clear separation between the query engine mechanics and the query language so that the language can be parsed and dealt with separate from the query engine itself.
2017-08-15 19:24:22 +00:00
Points: [][]query.Point{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
{&query.FloatPoint{Name: "cpu", Time: 0 * Second, Value: 40}},
{&query.FloatPoint{Name: "cpu", Time: 5 * Second, Value: 20}},
{&query.FloatPoint{Name: "cpu", Time: 9 * Second, Value: 38}},
Support integer literals in the query language Numbers in the query without any decimal will now be emitted as integers instead and be parsed as an IntegerLiteral. This ensures we keep the original context that a query was issued with and allows us to act more similar to how programming languages are typically structured when it comes to floats and ints. This adds functionality for dealing with integers promoting to floats in the various different places where math are used. Fixes #5744 and #5629.
2016-02-19 04:06:41 +00:00
},
},
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
Name: "MultiplicationLHS_Number",
Support integer literals in the query language Numbers in the query without any decimal will now be emitted as integers instead and be parsed as an IntegerLiteral. This ensures we keep the original context that a query was issued with and allows us to act more similar to how programming languages are typically structured when it comes to floats and ints. This adds functionality for dealing with integers promoting to floats in the various different places where math are used. Fixes #5744 and #5629.
2016-02-19 04:06:41 +00:00
Statement: `SELECT 2.0 * value FROM cpu`,
Separate the query engine into a separate package This change provides a clear separation between the query engine mechanics and the query language so that the language can be parsed and dealt with separate from the query engine itself.
2017-08-15 19:24:22 +00:00
Points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Time: 0 * Second, Value: 40}},
{&query.FloatPoint{Name: "cpu", Time: 5 * Second, Value: 20}},
{&query.FloatPoint{Name: "cpu", Time: 9 * Second, Value: 38}},
Add binary expr tests to influxql package No boolean operator tests because the parser doesn't currently allow it. I am currently keeping the code that performs this for now until we decide whether to allow boolean operators inside of a select clause. It would be easy to have the new query engine do something like this: SELECT mean(value) < 10 FROM cpu GROUP BY time(1m) And then you would have it return true or false for each interval, but the same can be done through a where clause too.
2016-02-01 22:08:37 +00:00
},
},
Support integer literals in the query language Numbers in the query without any decimal will now be emitted as integers instead and be parsed as an IntegerLiteral. This ensures we keep the original context that a query was issued with and allows us to act more similar to how programming languages are typically structured when it comes to floats and ints. This adds functionality for dealing with integers promoting to floats in the various different places where math are used. Fixes #5744 and #5629.
2016-02-19 04:06:41 +00:00
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
Name: "MultiplicationLHS_Integer",
Support integer literals in the query language Numbers in the query without any decimal will now be emitted as integers instead and be parsed as an IntegerLiteral. This ensures we keep the original context that a query was issued with and allows us to act more similar to how programming languages are typically structured when it comes to floats and ints. This adds functionality for dealing with integers promoting to floats in the various different places where math are used. Fixes #5744 and #5629.
2016-02-19 04:06:41 +00:00
Statement: `SELECT 2 * value FROM cpu`,
Separate the query engine into a separate package This change provides a clear separation between the query engine mechanics and the query language so that the language can be parsed and dealt with separate from the query engine itself.
2017-08-15 19:24:22 +00:00
Points: [][]query.Point{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
{&query.FloatPoint{Name: "cpu", Time: 0 * Second, Value: 40}},
{&query.FloatPoint{Name: "cpu", Time: 5 * Second, Value: 20}},
{&query.FloatPoint{Name: "cpu", Time: 9 * Second, Value: 38}},
Support integer literals in the query language Numbers in the query without any decimal will now be emitted as integers instead and be parsed as an IntegerLiteral. This ensures we keep the original context that a query was issued with and allows us to act more similar to how programming languages are typically structured when it comes to floats and ints. This adds functionality for dealing with integers promoting to floats in the various different places where math are used. Fixes #5744 and #5629.
2016-02-19 04:06:41 +00:00
},
},
Improve test coverage in influxql package
2016-02-08 22:26:36 +00:00
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
Name: "TwoVariableMultiplication",
Improve test coverage in influxql package
2016-02-08 22:26:36 +00:00
Statement: `SELECT value * value FROM cpu`,
Separate the query engine into a separate package This change provides a clear separation between the query engine mechanics and the query language so that the language can be parsed and dealt with separate from the query engine itself.
2017-08-15 19:24:22 +00:00
Points: [][]query.Point{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
{&query.FloatPoint{Name: "cpu", Time: 0 * Second, Value: 400}},
{&query.FloatPoint{Name: "cpu", Time: 5 * Second, Value: 100}},
{&query.FloatPoint{Name: "cpu", Time: 9 * Second, Value: 361}},
Improve test coverage in influxql package
2016-02-08 22:26:36 +00:00
},
},
Add binary expr tests to influxql package No boolean operator tests because the parser doesn't currently allow it. I am currently keeping the code that performs this for now until we decide whether to allow boolean operators inside of a select clause. It would be easy to have the new query engine do something like this: SELECT mean(value) < 10 FROM cpu GROUP BY time(1m) And then you would have it return true or false for each interval, but the same can be done through a where clause too.
2016-02-01 22:08:37 +00:00
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
Name: "SubtractionRHS_Number",
Support integer literals in the query language Numbers in the query without any decimal will now be emitted as integers instead and be parsed as an IntegerLiteral. This ensures we keep the original context that a query was issued with and allows us to act more similar to how programming languages are typically structured when it comes to floats and ints. This adds functionality for dealing with integers promoting to floats in the various different places where math are used. Fixes #5744 and #5629.
2016-02-19 04:06:41 +00:00
Statement: `SELECT value - 2.0 FROM cpu`,
Separate the query engine into a separate package This change provides a clear separation between the query engine mechanics and the query language so that the language can be parsed and dealt with separate from the query engine itself.
2017-08-15 19:24:22 +00:00
Points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Time: 0 * Second, Value: 18}},
{&query.FloatPoint{Name: "cpu", Time: 5 * Second, Value: 8}},
{&query.FloatPoint{Name: "cpu", Time: 9 * Second, Value: 17}},
Add binary expr tests to influxql package No boolean operator tests because the parser doesn't currently allow it. I am currently keeping the code that performs this for now until we decide whether to allow boolean operators inside of a select clause. It would be easy to have the new query engine do something like this: SELECT mean(value) < 10 FROM cpu GROUP BY time(1m) And then you would have it return true or false for each interval, but the same can be done through a where clause too.
2016-02-01 22:08:37 +00:00
},
},
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
Name: "SubtractionRHS_Integer",
Support integer literals in the query language Numbers in the query without any decimal will now be emitted as integers instead and be parsed as an IntegerLiteral. This ensures we keep the original context that a query was issued with and allows us to act more similar to how programming languages are typically structured when it comes to floats and ints. This adds functionality for dealing with integers promoting to floats in the various different places where math are used. Fixes #5744 and #5629.
2016-02-19 04:06:41 +00:00
Statement: `SELECT value - 2 FROM cpu`,
Separate the query engine into a separate package This change provides a clear separation between the query engine mechanics and the query language so that the language can be parsed and dealt with separate from the query engine itself.
2017-08-15 19:24:22 +00:00
Points: [][]query.Point{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
{&query.FloatPoint{Name: "cpu", Time: 0 * Second, Value: 18}},
{&query.FloatPoint{Name: "cpu", Time: 5 * Second, Value: 8}},
{&query.FloatPoint{Name: "cpu", Time: 9 * Second, Value: 17}},
Support integer literals in the query language Numbers in the query without any decimal will now be emitted as integers instead and be parsed as an IntegerLiteral. This ensures we keep the original context that a query was issued with and allows us to act more similar to how programming languages are typically structured when it comes to floats and ints. This adds functionality for dealing with integers promoting to floats in the various different places where math are used. Fixes #5744 and #5629.
2016-02-19 04:06:41 +00:00
},
},
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
Name: "SubtractionLHS_Number",
Support integer literals in the query language Numbers in the query without any decimal will now be emitted as integers instead and be parsed as an IntegerLiteral. This ensures we keep the original context that a query was issued with and allows us to act more similar to how programming languages are typically structured when it comes to floats and ints. This adds functionality for dealing with integers promoting to floats in the various different places where math are used. Fixes #5744 and #5629.
2016-02-19 04:06:41 +00:00
Statement: `SELECT 2.0 - value FROM cpu`,
Separate the query engine into a separate package This change provides a clear separation between the query engine mechanics and the query language so that the language can be parsed and dealt with separate from the query engine itself.
2017-08-15 19:24:22 +00:00
Points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Time: 0 * Second, Value: -18}},
{&query.FloatPoint{Name: "cpu", Time: 5 * Second, Value: -8}},
{&query.FloatPoint{Name: "cpu", Time: 9 * Second, Value: -17}},
Add binary expr tests to influxql package No boolean operator tests because the parser doesn't currently allow it. I am currently keeping the code that performs this for now until we decide whether to allow boolean operators inside of a select clause. It would be easy to have the new query engine do something like this: SELECT mean(value) < 10 FROM cpu GROUP BY time(1m) And then you would have it return true or false for each interval, but the same can be done through a where clause too.
2016-02-01 22:08:37 +00:00
},
},
Support integer literals in the query language Numbers in the query without any decimal will now be emitted as integers instead and be parsed as an IntegerLiteral. This ensures we keep the original context that a query was issued with and allows us to act more similar to how programming languages are typically structured when it comes to floats and ints. This adds functionality for dealing with integers promoting to floats in the various different places where math are used. Fixes #5744 and #5629.
2016-02-19 04:06:41 +00:00
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
Name: "SubtractionLHS_Integer",
Support integer literals in the query language Numbers in the query without any decimal will now be emitted as integers instead and be parsed as an IntegerLiteral. This ensures we keep the original context that a query was issued with and allows us to act more similar to how programming languages are typically structured when it comes to floats and ints. This adds functionality for dealing with integers promoting to floats in the various different places where math are used. Fixes #5744 and #5629.
2016-02-19 04:06:41 +00:00
Statement: `SELECT 2 - value FROM cpu`,
Separate the query engine into a separate package This change provides a clear separation between the query engine mechanics and the query language so that the language can be parsed and dealt with separate from the query engine itself.
2017-08-15 19:24:22 +00:00
Points: [][]query.Point{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
{&query.FloatPoint{Name: "cpu", Time: 0 * Second, Value: -18}},
{&query.FloatPoint{Name: "cpu", Time: 5 * Second, Value: -8}},
{&query.FloatPoint{Name: "cpu", Time: 9 * Second, Value: -17}},
Support integer literals in the query language Numbers in the query without any decimal will now be emitted as integers instead and be parsed as an IntegerLiteral. This ensures we keep the original context that a query was issued with and allows us to act more similar to how programming languages are typically structured when it comes to floats and ints. This adds functionality for dealing with integers promoting to floats in the various different places where math are used. Fixes #5744 and #5629.
2016-02-19 04:06:41 +00:00
},
},
Improve test coverage in influxql package
2016-02-08 22:26:36 +00:00
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
Name: "TwoVariableSubtraction",
Improve test coverage in influxql package
2016-02-08 22:26:36 +00:00
Statement: `SELECT value - value FROM cpu`,
Separate the query engine into a separate package This change provides a clear separation between the query engine mechanics and the query language so that the language can be parsed and dealt with separate from the query engine itself.
2017-08-15 19:24:22 +00:00
Points: [][]query.Point{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
{&query.FloatPoint{Name: "cpu", Time: 0 * Second, Value: 0}},
{&query.FloatPoint{Name: "cpu", Time: 5 * Second, Value: 0}},
{&query.FloatPoint{Name: "cpu", Time: 9 * Second, Value: 0}},
Improve test coverage in influxql package
2016-02-08 22:26:36 +00:00
},
},
Add binary expr tests to influxql package No boolean operator tests because the parser doesn't currently allow it. I am currently keeping the code that performs this for now until we decide whether to allow boolean operators inside of a select clause. It would be easy to have the new query engine do something like this: SELECT mean(value) < 10 FROM cpu GROUP BY time(1m) And then you would have it return true or false for each interval, but the same can be done through a where clause too.
2016-02-01 22:08:37 +00:00
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
Name: "DivisionRHS_Number",
Support integer literals in the query language Numbers in the query without any decimal will now be emitted as integers instead and be parsed as an IntegerLiteral. This ensures we keep the original context that a query was issued with and allows us to act more similar to how programming languages are typically structured when it comes to floats and ints. This adds functionality for dealing with integers promoting to floats in the various different places where math are used. Fixes #5744 and #5629.
2016-02-19 04:06:41 +00:00
Statement: `SELECT value / 2.0 FROM cpu`,
Separate the query engine into a separate package This change provides a clear separation between the query engine mechanics and the query language so that the language can be parsed and dealt with separate from the query engine itself.
2017-08-15 19:24:22 +00:00
Points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Time: 0 * Second, Value: 10}},
{&query.FloatPoint{Name: "cpu", Time: 5 * Second, Value: 5}},
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
{&query.FloatPoint{Name: "cpu", Time: 9 * Second, Value: float64(19) / 2}},
Add binary expr tests to influxql package No boolean operator tests because the parser doesn't currently allow it. I am currently keeping the code that performs this for now until we decide whether to allow boolean operators inside of a select clause. It would be easy to have the new query engine do something like this: SELECT mean(value) < 10 FROM cpu GROUP BY time(1m) And then you would have it return true or false for each interval, but the same can be done through a where clause too.
2016-02-01 22:08:37 +00:00
},
},
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
Name: "DivisionRHS_Integer",
Support integer literals in the query language Numbers in the query without any decimal will now be emitted as integers instead and be parsed as an IntegerLiteral. This ensures we keep the original context that a query was issued with and allows us to act more similar to how programming languages are typically structured when it comes to floats and ints. This adds functionality for dealing with integers promoting to floats in the various different places where math are used. Fixes #5744 and #5629.
2016-02-19 04:06:41 +00:00
Statement: `SELECT value / 2 FROM cpu`,
Separate the query engine into a separate package This change provides a clear separation between the query engine mechanics and the query language so that the language can be parsed and dealt with separate from the query engine itself.
2017-08-15 19:24:22 +00:00
Points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Time: 0 * Second, Value: 10}},
{&query.FloatPoint{Name: "cpu", Time: 5 * Second, Value: 5}},
{&query.FloatPoint{Name: "cpu", Time: 9 * Second, Value: float64(19) / 2}},
Support integer literals in the query language Numbers in the query without any decimal will now be emitted as integers instead and be parsed as an IntegerLiteral. This ensures we keep the original context that a query was issued with and allows us to act more similar to how programming languages are typically structured when it comes to floats and ints. This adds functionality for dealing with integers promoting to floats in the various different places where math are used. Fixes #5744 and #5629.
2016-02-19 04:06:41 +00:00
},
},
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
Name: "DivisionLHS_Number",
Support integer literals in the query language Numbers in the query without any decimal will now be emitted as integers instead and be parsed as an IntegerLiteral. This ensures we keep the original context that a query was issued with and allows us to act more similar to how programming languages are typically structured when it comes to floats and ints. This adds functionality for dealing with integers promoting to floats in the various different places where math are used. Fixes #5744 and #5629.
2016-02-19 04:06:41 +00:00
Statement: `SELECT 38.0 / value FROM cpu`,
Separate the query engine into a separate package This change provides a clear separation between the query engine mechanics and the query language so that the language can be parsed and dealt with separate from the query engine itself.
2017-08-15 19:24:22 +00:00
Points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Time: 0 * Second, Value: 1.9}},
{&query.FloatPoint{Name: "cpu", Time: 5 * Second, Value: 3.8}},
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
{&query.FloatPoint{Name: "cpu", Time: 9 * Second, Value: 2}},
Add binary expr tests to influxql package No boolean operator tests because the parser doesn't currently allow it. I am currently keeping the code that performs this for now until we decide whether to allow boolean operators inside of a select clause. It would be easy to have the new query engine do something like this: SELECT mean(value) < 10 FROM cpu GROUP BY time(1m) And then you would have it return true or false for each interval, but the same can be done through a where clause too.
2016-02-01 22:08:37 +00:00
},
},
Support integer literals in the query language Numbers in the query without any decimal will now be emitted as integers instead and be parsed as an IntegerLiteral. This ensures we keep the original context that a query was issued with and allows us to act more similar to how programming languages are typically structured when it comes to floats and ints. This adds functionality for dealing with integers promoting to floats in the various different places where math are used. Fixes #5744 and #5629.
2016-02-19 04:06:41 +00:00
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
Name: "DivisionLHS_Integer",
Support integer literals in the query language Numbers in the query without any decimal will now be emitted as integers instead and be parsed as an IntegerLiteral. This ensures we keep the original context that a query was issued with and allows us to act more similar to how programming languages are typically structured when it comes to floats and ints. This adds functionality for dealing with integers promoting to floats in the various different places where math are used. Fixes #5744 and #5629.
2016-02-19 04:06:41 +00:00
Statement: `SELECT 38 / value FROM cpu`,
Separate the query engine into a separate package This change provides a clear separation between the query engine mechanics and the query language so that the language can be parsed and dealt with separate from the query engine itself.
2017-08-15 19:24:22 +00:00
Points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Time: 0 * Second, Value: 1.9}},
{&query.FloatPoint{Name: "cpu", Time: 5 * Second, Value: 3.8}},
{&query.FloatPoint{Name: "cpu", Time: 9 * Second, Value: 2}},
Support integer literals in the query language Numbers in the query without any decimal will now be emitted as integers instead and be parsed as an IntegerLiteral. This ensures we keep the original context that a query was issued with and allows us to act more similar to how programming languages are typically structured when it comes to floats and ints. This adds functionality for dealing with integers promoting to floats in the various different places where math are used. Fixes #5744 and #5629.
2016-02-19 04:06:41 +00:00
},
},
Improve test coverage in influxql package
2016-02-08 22:26:36 +00:00
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
Name: "TwoVariableDivision",
Improve test coverage in influxql package
2016-02-08 22:26:36 +00:00
Statement: `SELECT value / value FROM cpu`,
Separate the query engine into a separate package This change provides a clear separation between the query engine mechanics and the query language so that the language can be parsed and dealt with separate from the query engine itself.
2017-08-15 19:24:22 +00:00
Points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Time: 0 * Second, Value: 1}},
{&query.FloatPoint{Name: "cpu", Time: 5 * Second, Value: 1}},
{&query.FloatPoint{Name: "cpu", Time: 9 * Second, Value: 1}},
Improve test coverage in influxql package
2016-02-08 22:26:36 +00:00
},
},
Add binary expr tests to influxql package No boolean operator tests because the parser doesn't currently allow it. I am currently keeping the code that performs this for now until we decide whether to allow boolean operators inside of a select clause. It would be easy to have the new query engine do something like this: SELECT mean(value) < 10 FROM cpu GROUP BY time(1m) And then you would have it return true or false for each interval, but the same can be done through a where clause too.
2016-02-01 22:08:37 +00:00
} {
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
t.Run(test.Name, func(t *testing.T) {
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
stmt := MustParseSelectStatement(test.Statement)
Pass the select options to the shard mapper again
2017-08-23 20:54:07 +00:00
itrs, _, err := query.Select(stmt, &shardMapper, query.SelectOptions{})
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
if err != nil {
t.Errorf("%s: parse error: %s", test.Name, err)
} else if a, err := Iterators(itrs).ReadAll(); err != nil {
t.Fatalf("%s: unexpected error: %s", test.Name, err)
} else if diff := cmp.Diff(a, test.Points); diff != "" {
t.Errorf("%s: unexpected points:\n%s", test.Name, diff)
}
})
Basic testing for binary expressions Use Iterators().ReadAll() in select unit tests.
2016-02-01 16:03:35 +00:00
}
}
Make sure parenthesized SELECT arguemnts are evaluated properly without panic Fixes #5630
2016-02-11 14:05:08 +00:00
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
// Ensure a SELECT binary expr queries can be executed as integers.
func TestSelect_BinaryExpr_Integer(t *testing.T) {
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
shardMapper := ShardMapper{
MapShardsFn: func(sources influxql.Sources, _ influxql.TimeRange) query.ShardGroup {
return &ShardGroup{
Fields: map[string]influxql.DataType{
"value": influxql.Integer,
},
CreateIteratorFn: func(m *influxql.Measurement, opt query.IteratorOptions) (query.Iterator, error) {
if m.Name != "cpu" {
t.Fatalf("unexpected source: %s", m.Name)
}
makeAuxFields := func(value int64) []interface{} {
aux := make([]interface{}, len(opt.Aux))
for i := range aux {
aux[i] = value
}
return aux
}
return &FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Time: 0 * Second, Aux: makeAuxFields(20)},
{Name: "cpu", Time: 5 * Second, Aux: makeAuxFields(10)},
{Name: "cpu", Time: 9 * Second, Aux: makeAuxFields(19)},
}}, nil
},
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
}
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
},
Support cast syntax for selecting a specific type Casting syntax is done with the PostgreSQL syntax `field1::float` to specify which type should be used when selecting a field. You can also do `field1::field` or `tag1::tag` to specify that a field or tag should be selected. This makes it possible to select a tag when a field key and a tag key conflict with each other in a measurement. It also means it's possible to choose a field with a specific type if multiple shards disagree. If no types are given, the same ordering for how a type is chosen is used to determine which type to return. The FieldDimensions method has been updated to return the data type for the fields that get returned. The SeriesKeys function has also been removed since it is no longer needed. SeriesKeys was originally used for the fill iterator, but then expanded to be used by auxiliary iterators for determining the channel iterator types. The fill iterator doesn't need it anymore and the auxiliary types are better served by FieldDimensions implementing that functionality, so SeriesKeys is no longer needed. Fixes #6519.
2016-05-16 16:08:28 +00:00
}
Update binary expressions to handle mixed math between integers and floats This also changes it so all NumericLiterals are treated as a float rather than sometimes being cast to an integer. Fixes #5740.
2016-02-18 21:37:03 +00:00
for _, test := range []struct {
Name string
Statement string
Separate the query engine into a separate package This change provides a clear separation between the query engine mechanics and the query language so that the language can be parsed and dealt with separate from the query engine itself.
2017-08-15 19:24:22 +00:00
Points [][]query.Point
Update binary expressions to handle mixed math between integers and floats This also changes it so all NumericLiterals are treated as a float rather than sometimes being cast to an integer. Fixes #5740.
2016-02-18 21:37:03 +00:00
}{
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
Name: "AdditionRHS_Number",
Statement: `SELECT value + 2.0 FROM cpu`,
Separate the query engine into a separate package This change provides a clear separation between the query engine mechanics and the query language so that the language can be parsed and dealt with separate from the query engine itself.
2017-08-15 19:24:22 +00:00
Points: [][]query.Point{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
{&query.FloatPoint{Name: "cpu", Time: 0 * Second, Value: 22}},
{&query.FloatPoint{Name: "cpu", Time: 5 * Second, Value: 12}},
{&query.FloatPoint{Name: "cpu", Time: 9 * Second, Value: 21}},
Update binary expressions to handle mixed math between integers and floats This also changes it so all NumericLiterals are treated as a float rather than sometimes being cast to an integer. Fixes #5740.
2016-02-18 21:37:03 +00:00
},
},
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
Name: "AdditionRHS_Integer",
Statement: `SELECT value + 2 FROM cpu`,
Separate the query engine into a separate package This change provides a clear separation between the query engine mechanics and the query language so that the language can be parsed and dealt with separate from the query engine itself.
2017-08-15 19:24:22 +00:00
Points: [][]query.Point{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
{&query.IntegerPoint{Name: "cpu", Time: 0 * Second, Value: 22}},
{&query.IntegerPoint{Name: "cpu", Time: 5 * Second, Value: 12}},
{&query.IntegerPoint{Name: "cpu", Time: 9 * Second, Value: 21}},
Update binary expressions to handle mixed math between integers and floats This also changes it so all NumericLiterals are treated as a float rather than sometimes being cast to an integer. Fixes #5740.
2016-02-18 21:37:03 +00:00
},
},
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
Name: "AdditionLHS_Number",
Statement: `SELECT 2.0 + value FROM cpu`,
Separate the query engine into a separate package This change provides a clear separation between the query engine mechanics and the query language so that the language can be parsed and dealt with separate from the query engine itself.
2017-08-15 19:24:22 +00:00
Points: [][]query.Point{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
{&query.FloatPoint{Name: "cpu", Time: 0 * Second, Value: 22}},
{&query.FloatPoint{Name: "cpu", Time: 5 * Second, Value: 12}},
{&query.FloatPoint{Name: "cpu", Time: 9 * Second, Value: 21}},
Update binary expressions to handle mixed math between integers and floats This also changes it so all NumericLiterals are treated as a float rather than sometimes being cast to an integer. Fixes #5740.
2016-02-18 21:37:03 +00:00
},
},
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
Name: "AdditionLHS_Integer",
Statement: `SELECT 2 + value FROM cpu`,
Separate the query engine into a separate package This change provides a clear separation between the query engine mechanics and the query language so that the language can be parsed and dealt with separate from the query engine itself.
2017-08-15 19:24:22 +00:00
Points: [][]query.Point{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
{&query.IntegerPoint{Name: "cpu", Time: 0 * Second, Value: 22}},
{&query.IntegerPoint{Name: "cpu", Time: 5 * Second, Value: 12}},
{&query.IntegerPoint{Name: "cpu", Time: 9 * Second, Value: 21}},
Update binary expressions to handle mixed math between integers and floats This also changes it so all NumericLiterals are treated as a float rather than sometimes being cast to an integer. Fixes #5740.
2016-02-18 21:37:03 +00:00
},
},
Add bitwise AND, OR and XOR operators to InfluxQL.
2017-03-19 09:58:09 +00:00
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
Name: "TwoVariableAddition",
Statement: `SELECT value + value FROM cpu`,
Separate the query engine into a separate package This change provides a clear separation between the query engine mechanics and the query language so that the language can be parsed and dealt with separate from the query engine itself.
2017-08-15 19:24:22 +00:00
Points: [][]query.Point{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
{&query.IntegerPoint{Name: "cpu", Time: 0 * Second, Value: 40}},
{&query.IntegerPoint{Name: "cpu", Time: 5 * Second, Value: 20}},
{&query.IntegerPoint{Name: "cpu", Time: 9 * Second, Value: 38}},
Add bitwise AND, OR and XOR operators to InfluxQL.
2017-03-19 09:58:09 +00:00
},
},
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
Name: "MultiplicationRHS_Number",
Statement: `SELECT value * 2.0 FROM cpu`,
Separate the query engine into a separate package This change provides a clear separation between the query engine mechanics and the query language so that the language can be parsed and dealt with separate from the query engine itself.
2017-08-15 19:24:22 +00:00
Points: [][]query.Point{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
{&query.FloatPoint{Name: "cpu", Time: 0 * Second, Value: 40}},
{&query.FloatPoint{Name: "cpu", Time: 5 * Second, Value: 20}},
{&query.FloatPoint{Name: "cpu", Time: 9 * Second, Value: 38}},
Add bitwise AND, OR and XOR operators to InfluxQL.
2017-03-19 09:58:09 +00:00
},
},
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
Name: "MultiplicationRHS_Integer",
Statement: `SELECT value * 2 FROM cpu`,
Separate the query engine into a separate package This change provides a clear separation between the query engine mechanics and the query language so that the language can be parsed and dealt with separate from the query engine itself.
2017-08-15 19:24:22 +00:00
Points: [][]query.Point{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
{&query.IntegerPoint{Name: "cpu", Time: 0 * Second, Value: 40}},
{&query.IntegerPoint{Name: "cpu", Time: 5 * Second, Value: 20}},
{&query.IntegerPoint{Name: "cpu", Time: 9 * Second, Value: 38}},
Add bitwise AND, OR and XOR operators to InfluxQL.
2017-03-19 09:58:09 +00:00
},
},
Support nil values in binary math expressions with two iterators Related to #5959 and #5973.
2016-03-11 15:58:16 +00:00
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
Name: "MultiplicationLHS_Number",
Statement: `SELECT 2.0 * value FROM cpu`,
Separate the query engine into a separate package This change provides a clear separation between the query engine mechanics and the query language so that the language can be parsed and dealt with separate from the query engine itself.
2017-08-15 19:24:22 +00:00
Points: [][]query.Point{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
{&query.FloatPoint{Name: "cpu", Time: 0 * Second, Value: 40}},
{&query.FloatPoint{Name: "cpu", Time: 5 * Second, Value: 20}},
{&query.FloatPoint{Name: "cpu", Time: 9 * Second, Value: 38}},
Support nil values in binary math expressions with two iterators Related to #5959 and #5973.
2016-03-11 15:58:16 +00:00
},
},
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
Name: "MultiplicationLHS_Integer",
Statement: `SELECT 2 * value FROM cpu`,
Separate the query engine into a separate package This change provides a clear separation between the query engine mechanics and the query language so that the language can be parsed and dealt with separate from the query engine itself.
2017-08-15 19:24:22 +00:00
Points: [][]query.Point{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
{&query.IntegerPoint{Name: "cpu", Time: 0 * Second, Value: 40}},
{&query.IntegerPoint{Name: "cpu", Time: 5 * Second, Value: 20}},
{&query.IntegerPoint{Name: "cpu", Time: 9 * Second, Value: 38}},
Support nil values in binary math expressions with two iterators Related to #5959 and #5973.
2016-03-11 15:58:16 +00:00
},
},
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
Name: "TwoVariableMultiplication",
Statement: `SELECT value * value FROM cpu`,
Separate the query engine into a separate package This change provides a clear separation between the query engine mechanics and the query language so that the language can be parsed and dealt with separate from the query engine itself.
2017-08-15 19:24:22 +00:00
Points: [][]query.Point{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
{&query.IntegerPoint{Name: "cpu", Time: 0 * Second, Value: 400}},
{&query.IntegerPoint{Name: "cpu", Time: 5 * Second, Value: 100}},
{&query.IntegerPoint{Name: "cpu", Time: 9 * Second, Value: 361}},
Support nil values in binary math expressions with two iterators Related to #5959 and #5973.
2016-03-11 15:58:16 +00:00
},
},
{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
Name: "SubtractionRHS_Number",
Statement: `SELECT value - 2.0 FROM cpu`,
Separate the query engine into a separate package This change provides a clear separation between the query engine mechanics and the query language so that the language can be parsed and dealt with separate from the query engine itself.
2017-08-15 19:24:22 +00:00
Points: [][]query.Point{
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
{&query.FloatPoint{Name: "cpu", Time: 0 * Second, Value: 18}},
{&query.FloatPoint{Name: "cpu", Time: 5 * Second, Value: 8}},
{&query.FloatPoint{Name: "cpu", Time: 9 * Second, Value: 17}},
Support nil values in binary math expressions with two iterators Related to #5959 and #5973.
2016-03-11 15:58:16 +00:00
},
},
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
{
Name: "SubtractionRHS_Integer",
Statement: `SELECT value - 2 FROM cpu`,
Points: [][]query.Point{
{&query.IntegerPoint{Name: "cpu", Time: 0 * Second, Value: 18}},
{&query.IntegerPoint{Name: "cpu", Time: 5 * Second, Value: 8}},
{&query.IntegerPoint{Name: "cpu", Time: 9 * Second, Value: 17}},
},
},
{
Name: "SubtractionLHS_Number",
Statement: `SELECT 2.0 - value FROM cpu`,
Points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Time: 0 * Second, Value: -18}},
{&query.FloatPoint{Name: "cpu", Time: 5 * Second, Value: -8}},
{&query.FloatPoint{Name: "cpu", Time: 9 * Second, Value: -17}},
},
},
{
Name: "SubtractionLHS_Integer",
Statement: `SELECT 2 - value FROM cpu`,
Points: [][]query.Point{
{&query.IntegerPoint{Name: "cpu", Time: 0 * Second, Value: -18}},
{&query.IntegerPoint{Name: "cpu", Time: 5 * Second, Value: -8}},
{&query.IntegerPoint{Name: "cpu", Time: 9 * Second, Value: -17}},
},
},
{
Name: "TwoVariableSubtraction",
Statement: `SELECT value - value FROM cpu`,
Points: [][]query.Point{
{&query.IntegerPoint{Name: "cpu", Time: 0 * Second, Value: 0}},
{&query.IntegerPoint{Name: "cpu", Time: 5 * Second, Value: 0}},
{&query.IntegerPoint{Name: "cpu", Time: 9 * Second, Value: 0}},
},
},
{
Name: "DivisionRHS_Number",
Statement: `SELECT value / 2.0 FROM cpu`,
Points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Time: 0 * Second, Value: 10}},
{&query.FloatPoint{Name: "cpu", Time: 5 * Second, Value: 5}},
{&query.FloatPoint{Name: "cpu", Time: 9 * Second, Value: 9.5}},
},
},
{
Name: "DivisionRHS_Integer",
Statement: `SELECT value / 2 FROM cpu`,
Points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Time: 0 * Second, Value: 10}},
{&query.FloatPoint{Name: "cpu", Time: 5 * Second, Value: 5}},
{&query.FloatPoint{Name: "cpu", Time: 9 * Second, Value: float64(19) / 2}},
},
},
{
Name: "DivisionLHS_Number",
Statement: `SELECT 38.0 / value FROM cpu`,
Points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Time: 0 * Second, Value: 1.9}},
{&query.FloatPoint{Name: "cpu", Time: 5 * Second, Value: 3.8}},
{&query.FloatPoint{Name: "cpu", Time: 9 * Second, Value: 2.0}},
},
},
{
Name: "DivisionLHS_Integer",
Statement: `SELECT 38 / value FROM cpu`,
Points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Time: 0 * Second, Value: 1.9}},
{&query.FloatPoint{Name: "cpu", Time: 5 * Second, Value: 3.8}},
{&query.FloatPoint{Name: "cpu", Time: 9 * Second, Value: 2}},
},
},
{
Name: "TwoVariablesDivision",
Statement: `SELECT value / value FROM cpu`,
Points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Time: 0 * Second, Value: 1}},
{&query.FloatPoint{Name: "cpu", Time: 5 * Second, Value: 1}},
{&query.FloatPoint{Name: "cpu", Time: 9 * Second, Value: 1}},
},
},
{
Name: "BitwiseAndRHS",
Statement: `SELECT value & 254 FROM cpu`,
Points: [][]query.Point{
{&query.IntegerPoint{Name: "cpu", Time: 0 * Second, Value: 20}},
{&query.IntegerPoint{Name: "cpu", Time: 5 * Second, Value: 10}},
{&query.IntegerPoint{Name: "cpu", Time: 9 * Second, Value: 18}},
},
},
{
Name: "BitwiseOrLHS",
Statement: `SELECT 4 | value FROM cpu`,
Points: [][]query.Point{
{&query.IntegerPoint{Name: "cpu", Time: 0 * Second, Value: 20}},
{&query.IntegerPoint{Name: "cpu", Time: 5 * Second, Value: 14}},
{&query.IntegerPoint{Name: "cpu", Time: 9 * Second, Value: 23}},
},
},
{
Name: "TwoVariableBitwiseXOr",
Statement: `SELECT value ^ value FROM cpu`,
Points: [][]query.Point{
{&query.IntegerPoint{Name: "cpu", Time: 0 * Second, Value: 0}},
{&query.IntegerPoint{Name: "cpu", Time: 5 * Second, Value: 0}},
{&query.IntegerPoint{Name: "cpu", Time: 9 * Second, Value: 0}},
},
},
} {
t.Run(test.Name, func(t *testing.T) {
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
stmt := MustParseSelectStatement(test.Statement)
Pass the select options to the shard mapper again
2017-08-23 20:54:07 +00:00
itrs, _, err := query.Select(stmt, &shardMapper, query.SelectOptions{})
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
if err != nil {
t.Errorf("%s: parse error: %s", test.Name, err)
} else if a, err := Iterators(itrs).ReadAll(); err != nil {
t.Fatalf("%s: unexpected error: %s", test.Name, err)
} else if diff := cmp.Diff(a, test.Points); diff != "" {
t.Errorf("%s: unexpected points:\n%s", test.Name, diff)
}
})
Add "integral" function to InfluxQL
2016-11-06 12:54:26 +00:00
}
}
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
// Ensure a SELECT binary expr queries can be executed on mixed iterators.
func TestSelect_BinaryExpr_Mixed(t *testing.T) {
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
shardMapper := ShardMapper{
MapShardsFn: func(sources influxql.Sources, _ influxql.TimeRange) query.ShardGroup {
return &ShardGroup{
Fields: map[string]influxql.DataType{
"total": influxql.Float,
"value": influxql.Integer,
},
CreateIteratorFn: func(m *influxql.Measurement, opt query.IteratorOptions) (query.Iterator, error) {
if m.Name != "cpu" {
t.Fatalf("unexpected source: %s", m.Name)
}
return &FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Time: 0 * Second, Aux: []interface{}{float64(20), int64(10)}},
{Name: "cpu", Time: 5 * Second, Aux: []interface{}{float64(10), int64(15)}},
{Name: "cpu", Time: 9 * Second, Aux: []interface{}{float64(19), int64(5)}},
}}, nil
},
}
},
Add "integral" function to InfluxQL
2016-11-06 12:54:26 +00:00
}
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
for _, test := range []struct {
Name string
Statement string
Points [][]query.Point
}{
{
Name: "Addition",
Statement: `SELECT total + value FROM cpu`,
Points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Time: 0 * Second, Value: 30}},
{&query.FloatPoint{Name: "cpu", Time: 5 * Second, Value: 25}},
{&query.FloatPoint{Name: "cpu", Time: 9 * Second, Value: 24}},
},
},
{
Name: "Subtraction",
Statement: `SELECT total - value FROM cpu`,
Points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Time: 0 * Second, Value: 10}},
{&query.FloatPoint{Name: "cpu", Time: 5 * Second, Value: -5}},
{&query.FloatPoint{Name: "cpu", Time: 9 * Second, Value: 14}},
},
},
{
Name: "Multiplication",
Statement: `SELECT total * value FROM cpu`,
Points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Time: 0 * Second, Value: 200}},
{&query.FloatPoint{Name: "cpu", Time: 5 * Second, Value: 150}},
{&query.FloatPoint{Name: "cpu", Time: 9 * Second, Value: 95}},
},
},
{
Name: "Division",
Statement: `SELECT total / value FROM cpu`,
Points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Time: 0 * Second, Value: 2}},
{&query.FloatPoint{Name: "cpu", Time: 5 * Second, Value: float64(10) / float64(15)}},
{&query.FloatPoint{Name: "cpu", Time: 9 * Second, Value: float64(19) / float64(5)}},
},
},
} {
t.Run(test.Name, func(t *testing.T) {
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
stmt := MustParseSelectStatement(test.Statement)
Pass the select options to the shard mapper again
2017-08-23 20:54:07 +00:00
itrs, _, err := query.Select(stmt, &shardMapper, query.SelectOptions{})
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
if err != nil {
t.Errorf("%s: parse error: %s", test.Name, err)
} else if a, err := Iterators(itrs).ReadAll(); err != nil {
t.Fatalf("%s: unexpected error: %s", test.Name, err)
} else if diff := cmp.Diff(a, test.Points); diff != "" {
t.Errorf("%s: unexpected points:\n%s", test.Name, diff)
}
})
Add "integral" function to InfluxQL
2016-11-06 12:54:26 +00:00
}
}
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
// Ensure a SELECT binary expr queries can be executed as booleans.
func TestSelect_BinaryExpr_Boolean(t *testing.T) {
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
shardMapper := ShardMapper{
MapShardsFn: func(sources influxql.Sources, _ influxql.TimeRange) query.ShardGroup {
return &ShardGroup{
Fields: map[string]influxql.DataType{
"one": influxql.Boolean,
"two": influxql.Boolean,
},
CreateIteratorFn: func(m *influxql.Measurement, opt query.IteratorOptions) (query.Iterator, error) {
if m.Name != "cpu" {
t.Fatalf("unexpected source: %s", m.Name)
}
makeAuxFields := func(value bool) []interface{} {
aux := make([]interface{}, len(opt.Aux))
for i := range aux {
aux[i] = value
}
return aux
}
return &FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Time: 0 * Second, Aux: makeAuxFields(true)},
{Name: "cpu", Time: 5 * Second, Aux: makeAuxFields(false)},
{Name: "cpu", Time: 9 * Second, Aux: makeAuxFields(true)},
}}, nil
},
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
}
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
},
Implement cumulative_sum() function The `cumulative_sum()` function can be used to sum each new point and output the current total. For the following points: cpu value=2 0 cpu value=4 10 cpu value=6 20 This would output the following points: > SELECT cumulative_sum(value) FROM cpu time value ---- ----- 0 2 10 6 20 12 As can be seen, each new point adds to the sum of the previous point and outputs the value with the same timestamp. The function can also be used with an aggregate like `derivative()`. > SELECT cumulative_sum(mean(value) FROM cpu WHERE time >= now() - 10m GROUP BY time(1m)
2016-10-07 15:11:50 +00:00
}
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
for _, test := range []struct {
Name string
Statement string
Points [][]query.Point
}{
{
Name: "BinaryXOrRHS",
Statement: `SELECT one ^ true FROM cpu`,
Points: [][]query.Point{
{&query.BooleanPoint{Name: "cpu", Time: 0 * Second, Value: false}},
{&query.BooleanPoint{Name: "cpu", Time: 5 * Second, Value: true}},
{&query.BooleanPoint{Name: "cpu", Time: 9 * Second, Value: false}},
},
},
{
Name: "BinaryOrLHS",
Statement: `SELECT true | two FROM cpu`,
Points: [][]query.Point{
{&query.BooleanPoint{Name: "cpu", Time: 0 * Second, Value: true}},
{&query.BooleanPoint{Name: "cpu", Time: 5 * Second, Value: true}},
{&query.BooleanPoint{Name: "cpu", Time: 9 * Second, Value: true}},
},
},
{
Name: "TwoSeriesBitwiseAnd",
Statement: `SELECT one & two FROM cpu`,
Points: [][]query.Point{
{&query.BooleanPoint{Name: "cpu", Time: 0 * Second, Value: true}},
{&query.BooleanPoint{Name: "cpu", Time: 5 * Second, Value: false}},
{&query.BooleanPoint{Name: "cpu", Time: 9 * Second, Value: true}},
},
},
} {
t.Run(test.Name, func(t *testing.T) {
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
stmt := MustParseSelectStatement(test.Statement)
Pass the select options to the shard mapper again
2017-08-23 20:54:07 +00:00
itrs, _, err := query.Select(stmt, &shardMapper, query.SelectOptions{})
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
if err != nil {
t.Errorf("%s: parse error: %s", test.Name, err)
} else if a, err := Iterators(itrs).ReadAll(); err != nil {
t.Fatalf("%s: unexpected error: %s", test.Name, err)
} else if diff := cmp.Diff(a, test.Points); diff != "" {
t.Errorf("%s: unexpected points:\n%s", test.Name, diff)
}
})
Implement cumulative_sum() function The `cumulative_sum()` function can be used to sum each new point and output the current total. For the following points: cpu value=2 0 cpu value=4 10 cpu value=6 20 This would output the following points: > SELECT cumulative_sum(value) FROM cpu time value ---- ----- 0 2 10 6 20 12 As can be seen, each new point adds to the sum of the previous point and outputs the value with the same timestamp. The function can also be used with an aggregate like `derivative()`. > SELECT cumulative_sum(mean(value) FROM cpu WHERE time >= now() - 10m GROUP BY time(1m)
2016-10-07 15:11:50 +00:00
}
}
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
// Ensure a SELECT binary expr with nil values can be executed.
// Nil values may be present when a field is missing from one iterator,
// but not the other.
func TestSelect_BinaryExpr_NilValues(t *testing.T) {
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
shardMapper := ShardMapper{
MapShardsFn: func(sources influxql.Sources, _ influxql.TimeRange) query.ShardGroup {
return &ShardGroup{
Fields: map[string]influxql.DataType{
"total": influxql.Float,
"value": influxql.Float,
},
CreateIteratorFn: func(m *influxql.Measurement, opt query.IteratorOptions) (query.Iterator, error) {
if m.Name != "cpu" {
t.Fatalf("unexpected source: %s", m.Name)
}
return &FloatIterator{Points: []query.FloatPoint{
{Name: "cpu", Time: 0 * Second, Value: 20, Aux: []interface{}{float64(20), nil}},
{Name: "cpu", Time: 5 * Second, Value: 10, Aux: []interface{}{float64(10), float64(15)}},
{Name: "cpu", Time: 9 * Second, Value: 19, Aux: []interface{}{nil, float64(5)}},
}}, nil
},
}
},
Implement cumulative_sum() function The `cumulative_sum()` function can be used to sum each new point and output the current total. For the following points: cpu value=2 0 cpu value=4 10 cpu value=6 20 This would output the following points: > SELECT cumulative_sum(value) FROM cpu time value ---- ----- 0 2 10 6 20 12 As can be seen, each new point adds to the sum of the previous point and outputs the value with the same timestamp. The function can also be used with an aggregate like `derivative()`. > SELECT cumulative_sum(mean(value) FROM cpu WHERE time >= now() - 10m GROUP BY time(1m)
2016-10-07 15:11:50 +00:00
}
Add Holt-Winters forecasting method.
2016-05-12 21:11:19 +00:00
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
for _, test := range []struct {
Name string
Statement string
Points [][]query.Point
}{
{
Name: "Addition",
Statement: `SELECT total + value FROM cpu`,
Points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Time: 0 * Second, Nil: true}},
{&query.FloatPoint{Name: "cpu", Time: 5 * Second, Value: 25}},
{&query.FloatPoint{Name: "cpu", Time: 9 * Second, Nil: true}},
},
},
{
Name: "Subtraction",
Statement: `SELECT total - value FROM cpu`,
Points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Time: 0 * Second, Nil: true}},
{&query.FloatPoint{Name: "cpu", Time: 5 * Second, Value: -5}},
{&query.FloatPoint{Name: "cpu", Time: 9 * Second, Nil: true}},
},
},
{
Name: "Multiplication",
Statement: `SELECT total * value FROM cpu`,
Points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Time: 0 * Second, Nil: true}},
{&query.FloatPoint{Name: "cpu", Time: 5 * Second, Value: 150}},
{&query.FloatPoint{Name: "cpu", Time: 9 * Second, Nil: true}},
},
},
{
Name: "Division",
Statement: `SELECT total / value FROM cpu`,
Points: [][]query.Point{
{&query.FloatPoint{Name: "cpu", Time: 0 * Second, Nil: true}},
{&query.FloatPoint{Name: "cpu", Time: 5 * Second, Value: float64(10) / float64(15)}},
{&query.FloatPoint{Name: "cpu", Time: 9 * Second, Nil: true}},
},
},
} {
t.Run(test.Name, func(t *testing.T) {
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
stmt := MustParseSelectStatement(test.Statement)
Pass the select options to the shard mapper again
2017-08-23 20:54:07 +00:00
itrs, _, err := query.Select(stmt, &shardMapper, query.SelectOptions{})
Refactor the select tests to use subtests and fewer functions This will allow refactoring the query engine and the select statement more easily since fewer code locations will need to be changed. It also reduces the amount of code while still keeping individual tests that are filterable.
2017-08-23 02:01:31 +00:00
if err != nil {
t.Errorf("%s: parse error: %s", test.Name, err)
} else if a, err := Iterators(itrs).ReadAll(); err != nil {
t.Fatalf("%s: unexpected error: %s", test.Name, err)
} else if diff := cmp.Diff(a, test.Points); diff != "" {
t.Errorf("%s: unexpected points:\n%s", test.Name, diff)
}
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
})
}
}
type ShardMapper struct {
MapShardsFn func(sources influxql.Sources, t influxql.TimeRange) query.ShardGroup
}
Pass the select options to the shard mapper again
2017-08-23 20:54:07 +00:00
func (m *ShardMapper) MapShards(sources influxql.Sources, t influxql.TimeRange, opt query.SelectOptions) (query.ShardGroup, error) {
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
shards := m.MapShardsFn(sources, t)
return shards, nil
}
type ShardGroup struct {
CreateIteratorFn func(m *influxql.Measurement, opt query.IteratorOptions) (query.Iterator, error)
Fields map[string]influxql.DataType
Dimensions []string
}
func (sh *ShardGroup) CreateIterator(m *influxql.Measurement, opt query.IteratorOptions) (query.Iterator, error) {
return sh.CreateIteratorFn(m, opt)
}
func (sh *ShardGroup) FieldDimensions(m *influxql.Measurement) (fields map[string]influxql.DataType, dimensions map[string]struct{}, err error) {
fields = make(map[string]influxql.DataType)
dimensions = make(map[string]struct{})
for f, typ := range sh.Fields {
fields[f] = typ
}
for _, d := range sh.Dimensions {
dimensions[d] = struct{}{}
}
return fields, dimensions, nil
}
func (sh *ShardGroup) MapType(m *influxql.Measurement, field string) influxql.DataType {
if typ, ok := sh.Fields[field]; ok {
return typ
}
for _, d := range sh.Dimensions {
if d == field {
return influxql.Tag
Return error message when improper types are used in SELECT Fixes #5949.
2016-03-09 16:36:18 +00:00
}
}
Move query engine code from the statement executor to the query engine The statement rewriting logic should be in the query engine as part of preparing a query. This creates a shard mapper interface that the query engine expects and then passes it to the query engine instead of requiring the query to be preprocessed before being input into the query engine. This interface is (mostly) the same as the old interface, just moved to a different package.
2017-08-22 18:18:41 +00:00
return influxql.Unknown
}
func (*ShardGroup) Close() error {
return nil
Return error message when improper types are used in SELECT Fixes #5949.
2016-03-09 16:36:18 +00:00
}
add double buffer on chan iterator This commit changes the channel iterators to use a double buffer to reduce allocations. The caller of `Iterator.Next()` must copy out the point before calling `Next()` again.
2016-04-14 17:08:41 +00:00
func BenchmarkSelect_Raw_1K(b *testing.B) { benchmarkSelectRaw(b, 1000) }
func BenchmarkSelect_Raw_100K(b *testing.B) { benchmarkSelectRaw(b, 1000000) }
func benchmarkSelectRaw(b *testing.B, pointN int) {
benchmarkSelect(b, MustParseSelectStatement(`SELECT fval FROM cpu`), NewRawBenchmarkIteratorCreator(pointN))
}
Add benchmark tests back
2017-08-25 04:20:58 +00:00
func benchmarkSelect(b *testing.B, stmt *influxql.SelectStatement, shardMapper query.ShardMapper) {
add double buffer on chan iterator This commit changes the channel iterators to use a double buffer to reduce allocations. The caller of `Iterator.Next()` must copy out the point before calling `Next()` again.
2016-04-14 17:08:41 +00:00
b.ReportAllocs()
for i := 0; i < b.N; i++ {
Add benchmark tests back
2017-08-25 04:20:58 +00:00
itrs, _, err := query.Select(stmt, shardMapper, query.SelectOptions{})
if err != nil {
b.Fatal(err)
}
query.DrainIterators(itrs)
add double buffer on chan iterator This commit changes the channel iterators to use a double buffer to reduce allocations. The caller of `Iterator.Next()` must copy out the point before calling `Next()` again.
2016-04-14 17:08:41 +00:00
}
}
// NewRawBenchmarkIteratorCreator returns a new mock iterator creator with generated fields.
Add benchmark tests back
2017-08-25 04:20:58 +00:00
func NewRawBenchmarkIteratorCreator(pointN int) query.ShardMapper {
return &ShardMapper{
MapShardsFn: func(sources influxql.Sources, t influxql.TimeRange) query.ShardGroup {
return &ShardGroup{
Fields: map[string]influxql.DataType{
"fval": influxql.Float,
},
CreateIteratorFn: func(m *influxql.Measurement, opt query.IteratorOptions) (query.Iterator, error) {
if opt.Expr != nil {
panic("unexpected expression")
}
add double buffer on chan iterator This commit changes the channel iterators to use a double buffer to reduce allocations. The caller of `Iterator.Next()` must copy out the point before calling `Next()` again.
2016-04-14 17:08:41 +00:00
Add benchmark tests back
2017-08-25 04:20:58 +00:00
p := query.FloatPoint{
Name: "cpu",
Aux: make([]interface{}, len(opt.Aux)),
}
add double buffer on chan iterator This commit changes the channel iterators to use a double buffer to reduce allocations. The caller of `Iterator.Next()` must copy out the point before calling `Next()` again.
2016-04-14 17:08:41 +00:00
Add benchmark tests back
2017-08-25 04:20:58 +00:00
for i := range opt.Aux {
switch opt.Aux[i].Val {
case "fval":
p.Aux[i] = float64(100)
default:
panic("unknown iterator expr: " + opt.Expr.String())
}
}
add double buffer on chan iterator This commit changes the channel iterators to use a double buffer to reduce allocations. The caller of `Iterator.Next()` must copy out the point before calling `Next()` again.
2016-04-14 17:08:41 +00:00
Add benchmark tests back
2017-08-25 04:20:58 +00:00
return &FloatPointGenerator{N: pointN, Fn: func(i int) *query.FloatPoint {
p.Time = int64(time.Duration(i) * (10 * time.Second))
return &p
}}, nil
},
}
},
add double buffer on chan iterator This commit changes the channel iterators to use a double buffer to reduce allocations. The caller of `Iterator.Next()` must copy out the point before calling `Next()` again.
2016-04-14 17:08:41 +00:00
}
}
Update SHOW TAG VALUES to use a fast dedupe iterator Include a benchmark test for the fast dedupe iterator.
2016-06-03 03:03:57 +00:00
func benchmarkSelectDedupe(b *testing.B, seriesN, pointsPerSeries int) {
stmt := MustParseSelectStatement(`SELECT sval::string FROM cpu`)
stmt.Dedupe = true
Add benchmark tests back
2017-08-25 04:20:58 +00:00
shardMapper := ShardMapper{
MapShardsFn: func(sources influxql.Sources, t influxql.TimeRange) query.ShardGroup {
return &ShardGroup{
Fields: map[string]influxql.DataType{
"sval": influxql.String,
},
CreateIteratorFn: func(m *influxql.Measurement, opt query.IteratorOptions) (query.Iterator, error) {
if opt.Expr != nil {
panic("unexpected expression")
}
Update SHOW TAG VALUES to use a fast dedupe iterator Include a benchmark test for the fast dedupe iterator.
2016-06-03 03:03:57 +00:00
Add benchmark tests back
2017-08-25 04:20:58 +00:00
p := query.FloatPoint{
Name: "tags",
Aux: []interface{}{nil},
}
Update SHOW TAG VALUES to use a fast dedupe iterator Include a benchmark test for the fast dedupe iterator.
2016-06-03 03:03:57 +00:00
Add benchmark tests back
2017-08-25 04:20:58 +00:00
return &FloatPointGenerator{N: seriesN * pointsPerSeries, Fn: func(i int) *query.FloatPoint {
p.Aux[0] = fmt.Sprintf("server%d", i%seriesN)
return &p
}}, nil
},
}
},
Update SHOW TAG VALUES to use a fast dedupe iterator Include a benchmark test for the fast dedupe iterator.
2016-06-03 03:03:57 +00:00
}
b.ResetTimer()
Add benchmark tests back
2017-08-25 04:20:58 +00:00
benchmarkSelect(b, stmt, &shardMapper)
Update SHOW TAG VALUES to use a fast dedupe iterator Include a benchmark test for the fast dedupe iterator.
2016-06-03 03:03:57 +00:00
}
func BenchmarkSelect_Dedupe_1K(b *testing.B) { benchmarkSelectDedupe(b, 1000, 100) }
Optimize top() and bottom() using an incremental aggregator The previous version of `top()` and `bottom()` would gather all of the points to use in a slice, filter them (if necessary), then use a slightly modified heap sort to retrieve the top or bottom values. This performed horrendously from the standpoint of memory. Since it consumed so much memory and spent so much time in allocations (along with sorting a potentially very large slice), this affected speed too. These calls have now been modified so they keep the top or bottom points in a min or max heap. For `top()`, a new point will read the minimum value from the heap. If the new point is greater than the minimum point, it will replace the minimum point and fix the heap with the new value. If the new point is smaller, it discards that point. For `bottom()`, the process is the opposite. It will then sort the final result to ensure the correct ordering of the selected points. When `top()` or `bottom()` contain a tag to select, they have now been modified so this query: SELECT top(value, host, 2) FROM cpu Essentially becomes this query: SELECT top(value, 2), host FROM ( SELECT max(value) FROM cpu GROUP BY host ) This should drastically increase the performance of all `top()` and `bottom()` queries.
2017-05-16 17:37:39 +00:00
func benchmarkSelectTop(b *testing.B, seriesN, pointsPerSeries int) {
stmt := MustParseSelectStatement(`SELECT top(sval, 10) FROM cpu`)
Add benchmark tests back
2017-08-25 04:20:58 +00:00
shardMapper := ShardMapper{
MapShardsFn: func(sources influxql.Sources, t influxql.TimeRange) query.ShardGroup {
return &ShardGroup{
Fields: map[string]influxql.DataType{
"sval": influxql.Float,
},
CreateIteratorFn: func(m *influxql.Measurement, opt query.IteratorOptions) (query.Iterator, error) {
if m.Name != "cpu" {
b.Fatalf("unexpected source: %s", m.Name)
}
if !reflect.DeepEqual(opt.Expr, MustParseExpr(`sval`)) {
b.Fatalf("unexpected expr: %s", spew.Sdump(opt.Expr))
}
Optimize top() and bottom() using an incremental aggregator The previous version of `top()` and `bottom()` would gather all of the points to use in a slice, filter them (if necessary), then use a slightly modified heap sort to retrieve the top or bottom values. This performed horrendously from the standpoint of memory. Since it consumed so much memory and spent so much time in allocations (along with sorting a potentially very large slice), this affected speed too. These calls have now been modified so they keep the top or bottom points in a min or max heap. For `top()`, a new point will read the minimum value from the heap. If the new point is greater than the minimum point, it will replace the minimum point and fix the heap with the new value. If the new point is smaller, it discards that point. For `bottom()`, the process is the opposite. It will then sort the final result to ensure the correct ordering of the selected points. When `top()` or `bottom()` contain a tag to select, they have now been modified so this query: SELECT top(value, host, 2) FROM cpu Essentially becomes this query: SELECT top(value, 2), host FROM ( SELECT max(value) FROM cpu GROUP BY host ) This should drastically increase the performance of all `top()` and `bottom()` queries.
2017-05-16 17:37:39 +00:00
Add benchmark tests back
2017-08-25 04:20:58 +00:00
p := query.FloatPoint{
Name: "cpu",
}
Optimize top() and bottom() using an incremental aggregator The previous version of `top()` and `bottom()` would gather all of the points to use in a slice, filter them (if necessary), then use a slightly modified heap sort to retrieve the top or bottom values. This performed horrendously from the standpoint of memory. Since it consumed so much memory and spent so much time in allocations (along with sorting a potentially very large slice), this affected speed too. These calls have now been modified so they keep the top or bottom points in a min or max heap. For `top()`, a new point will read the minimum value from the heap. If the new point is greater than the minimum point, it will replace the minimum point and fix the heap with the new value. If the new point is smaller, it discards that point. For `bottom()`, the process is the opposite. It will then sort the final result to ensure the correct ordering of the selected points. When `top()` or `bottom()` contain a tag to select, they have now been modified so this query: SELECT top(value, host, 2) FROM cpu Essentially becomes this query: SELECT top(value, 2), host FROM ( SELECT max(value) FROM cpu GROUP BY host ) This should drastically increase the performance of all `top()` and `bottom()` queries.
2017-05-16 17:37:39 +00:00
Add benchmark tests back
2017-08-25 04:20:58 +00:00
return &FloatPointGenerator{N: seriesN * pointsPerSeries, Fn: func(i int) *query.FloatPoint {
p.Value = float64(rand.Int63())
p.Time = int64(time.Duration(i) * (10 * time.Second))
return &p
}}, nil
},
}
},
Optimize top() and bottom() using an incremental aggregator The previous version of `top()` and `bottom()` would gather all of the points to use in a slice, filter them (if necessary), then use a slightly modified heap sort to retrieve the top or bottom values. This performed horrendously from the standpoint of memory. Since it consumed so much memory and spent so much time in allocations (along with sorting a potentially very large slice), this affected speed too. These calls have now been modified so they keep the top or bottom points in a min or max heap. For `top()`, a new point will read the minimum value from the heap. If the new point is greater than the minimum point, it will replace the minimum point and fix the heap with the new value. If the new point is smaller, it discards that point. For `bottom()`, the process is the opposite. It will then sort the final result to ensure the correct ordering of the selected points. When `top()` or `bottom()` contain a tag to select, they have now been modified so this query: SELECT top(value, host, 2) FROM cpu Essentially becomes this query: SELECT top(value, 2), host FROM ( SELECT max(value) FROM cpu GROUP BY host ) This should drastically increase the performance of all `top()` and `bottom()` queries.
2017-05-16 17:37:39 +00:00
}
b.ResetTimer()
Add benchmark tests back
2017-08-25 04:20:58 +00:00
benchmarkSelect(b, stmt, &shardMapper)
Optimize top() and bottom() using an incremental aggregator The previous version of `top()` and `bottom()` would gather all of the points to use in a slice, filter them (if necessary), then use a slightly modified heap sort to retrieve the top or bottom values. This performed horrendously from the standpoint of memory. Since it consumed so much memory and spent so much time in allocations (along with sorting a potentially very large slice), this affected speed too. These calls have now been modified so they keep the top or bottom points in a min or max heap. For `top()`, a new point will read the minimum value from the heap. If the new point is greater than the minimum point, it will replace the minimum point and fix the heap with the new value. If the new point is smaller, it discards that point. For `bottom()`, the process is the opposite. It will then sort the final result to ensure the correct ordering of the selected points. When `top()` or `bottom()` contain a tag to select, they have now been modified so this query: SELECT top(value, host, 2) FROM cpu Essentially becomes this query: SELECT top(value, 2), host FROM ( SELECT max(value) FROM cpu GROUP BY host ) This should drastically increase the performance of all `top()` and `bottom()` queries.
2017-05-16 17:37:39 +00:00
}
func BenchmarkSelect_Top_1K(b *testing.B) { benchmarkSelectTop(b, 1000, 1000) }