func TestIteratorOptions_DerivativeInterval_Default(t *testing.T) {
opt := influxql.IteratorOptions{}
expected := influxql.Interval{Duration: time.Second}
actual := opt.DerivativeInterval()
if actual != expected {
t.Errorf("expected derivative interval to be %v, got %v", expected, actual)
}
}
func TestIteratorOptions_SeekTime_Descending(t *testing.T) {
opt := influxql.IteratorOptions{
StartTime: 30,
EndTime: 60,
Ascending: false,
}
time := opt.SeekTime()
if time != 60 {
t.Errorf("expected time to be 60, got %d", time)
}
}
func TestIteratorOptions_DerivativeInterval_GroupBy(t *testing.T) {
opt := influxql.IteratorOptions{
Interval: influxql.Interval{
Duration: 10,
Offset: 2,
},
}
expected := influxql.Interval{Duration: 10}
actual := opt.DerivativeInterval()
if actual != expected {
t.Errorf("expected derivative interval to be %v, got %v", expected, actual)
}
}
func TestIteratorOptions_Window_Default(t *testing.T) {
opt := influxql.IteratorOptions{
StartTime: 0,
EndTime: 60,
}
start, end := opt.Window(34)
if start != 0 {
t.Errorf("expected start to be 0, got %d", start)
}
if end != 61 {
t.Errorf("expected end to be 61, got %d", end)
}
}
func TestIteratorOptions_Window_Interval(t *testing.T) {
opt := influxql.IteratorOptions{
Interval: influxql.Interval{
Duration: 10,
},
}
start, end := opt.Window(4)
if start != 0 {
t.Errorf("expected start to be 0, got %d", start)
}
if end != 10 {
t.Errorf("expected end to be 10, got %d", end)
}
}
func TestIteratorOptions_Window_Offset(t *testing.T) {
opt := influxql.IteratorOptions{
Interval: influxql.Interval{
Duration: 10,
Offset: 8,
},
}
start, end := opt.Window(14)
if start != 8 {
t.Errorf("expected start to be 8, got %d", start)
}
if end != 18 {
t.Errorf("expected end to be 18, got %d", end)
}
}
func TestIteratorOptions_DerivativeInterval_Call(t *testing.T) {
opt := influxql.IteratorOptions{
Expr: &influxql.Call{
Name: "mean",
Args: []influxql.Expr{
&influxql.VarRef{Val: "value"},
&influxql.DurationLiteral{Val: 2 * time.Second},
},
},
Interval: influxql.Interval{
Duration: 10,
Offset: 2,
},
}
expected := influxql.Interval{Duration: 2 * time.Second}
actual := opt.DerivativeInterval()
if actual != expected {
t.Errorf("expected derivative interval to be %v, got %v", expected, actual)
}
}
// Ensure iterator options with a regex measurement can be marshaled.
func TestIteratorOptions_MarshalBinary_Measurement_Regex(t *testing.T) {
opt := &influxql.IteratorOptions{
Sources: []influxql.Source{
&influxql.Measurement{Database: "db1", RetentionPolicy: "rp2", Regex: &influxql.RegexLiteral{Val: regexp.MustCompile(`series.+`)}},
},
}
// Marshal to binary.
buf, err := opt.MarshalBinary()
if err != nil {
t.Fatal(err)
}
// Unmarshal back to an object.
var other influxql.IteratorOptions
if err := other.UnmarshalBinary(buf); err != nil {
t.Fatal(err)
} else if v := other.Sources[0].(*influxql.Measurement).Regex.Val.String(); v != `/series.+/` {
t.Fatalf("unexpected measurement regex: %s", v)
}
}
// Ensure iterator options can be marshaled to and from a binary format.
func TestIteratorOptions_MarshalBinary(t *testing.T) {
opt := &influxql.IteratorOptions{
Expr: MustParseExpr("count(value)"),
Aux: []string{"a", "b", "c"},
Sources: []influxql.Source{
&influxql.Measurement{Database: "db0", RetentionPolicy: "rp0", Name: "mm0"},
},
Interval: influxql.Interval{
Duration: 1 * time.Hour,
Offset: 20 * time.Minute,
},
Dimensions: []string{"region", "host"},
Fill: influxql.NumberFill,
FillValue: float64(100),
Condition: MustParseExpr(`foo = 'bar'`),
StartTime: 1000,
EndTime: 2000,
Ascending: true,
Limit: 100,
Offset: 200,
SLimit: 300,
SOffset: 400,
Dedupe: true,
}
// Marshal to binary.
buf, err := opt.MarshalBinary()
if err != nil {
t.Fatal(err)
}
// Unmarshal back to an object.
var other influxql.IteratorOptions
if err := other.UnmarshalBinary(buf); err != nil {
t.Fatal(err)
} else if !reflect.DeepEqual(&other, opt) {
t.Fatalf("unexpected options: %s", spew.Sdump(other))
}
}
func TestIteratorOptions_MergeSorted(t *testing.T) {
opt := influxql.IteratorOptions{}
sorted := opt.MergeSorted()
if !sorted {
t.Error("expected no expression to be sorted, got unsorted")
}
opt.Expr = &influxql.VarRef{}
sorted = opt.MergeSorted()
if !sorted {
t.Error("expected expression with varref to be sorted, got unsorted")
}
opt.Expr = &influxql.Call{}
sorted = opt.MergeSorted()
if sorted {
t.Error("expected expression without varref to be unsorted, got sorted")
}
}
// buildBooleanCursor creates a cursor for a boolean field.
func (e *Engine) buildBooleanCursor(measurement, seriesKey, field string, opt influxql.IteratorOptions) booleanCursor {
cacheValues := e.Cache.Values(SeriesFieldKey(seriesKey, field))
keyCursor := e.KeyCursor(SeriesFieldKey(seriesKey, field), opt.SeekTime(), opt.Ascending)
return newBooleanCursor(opt.SeekTime(), opt.Ascending, cacheValues, keyCursor)
}