diff --git a/pkg/tsdb/postgres/macros.go b/pkg/tsdb/postgres/macros.go index 3ada39a9919..a21e9816bf5 100644 --- a/pkg/tsdb/postgres/macros.go +++ b/pkg/tsdb/postgres/macros.go @@ -109,7 +109,7 @@ func (m *postgresMacroEngine) evaluateMacro(name string, args []string) (string, } if m.timescaledb { - return fmt.Sprintf("time_bucket('%.0fs',%s)", interval.Seconds(), args[0]), nil + return fmt.Sprintf("time_bucket('%.1fs',%s)", interval.Seconds(), args[0]), nil } return fmt.Sprintf( diff --git a/pkg/tsdb/postgres/macros_test.go b/pkg/tsdb/postgres/macros_test.go index 0d177b9e889..53418e86f55 100644 --- a/pkg/tsdb/postgres/macros_test.go +++ b/pkg/tsdb/postgres/macros_test.go @@ -7,217 +7,210 @@ import ( "time" "github.com/grafana/grafana/pkg/plugins" - . "github.com/smartystreets/goconvey/convey" + "github.com/stretchr/testify/require" ) func TestMacroEngine(t *testing.T) { - Convey("MacroEngine", t, func() { - timescaledbEnabled := false - engine := newPostgresMacroEngine(timescaledbEnabled) - timescaledbEnabled = true - engineTS := newPostgresMacroEngine(timescaledbEnabled) - query := plugins.DataSubQuery{} + timescaledbEnabled := false + engine := newPostgresMacroEngine(timescaledbEnabled) + timescaledbEnabled = true + engineTS := newPostgresMacroEngine(timescaledbEnabled) + query := plugins.DataSubQuery{} - Convey("Given a time range between 2018-04-12 00:00 and 2018-04-12 00:05", func() { - from := time.Date(2018, 4, 12, 18, 0, 0, 0, time.UTC) - to := from.Add(5 * time.Minute) - timeRange := plugins.DataTimeRange{From: "5m", To: "now", Now: to} + t.Run("Given a time range between 2018-04-12 00:00 and 2018-04-12 00:05", func(t *testing.T) { + from := time.Date(2018, 4, 12, 18, 0, 0, 0, time.UTC) + to := from.Add(5 * time.Minute) + timeRange := plugins.DataTimeRange{From: "5m", To: "now", Now: to} - Convey("interpolate __time function", func() { - sql, err := engine.Interpolate(query, timeRange, "select $__time(time_column)") - So(err, ShouldBeNil) - - So(sql, ShouldEqual, "select time_column AS \"time\"") - }) - - Convey("interpolate __time function wrapped in aggregation", func() { - sql, err := engine.Interpolate(query, timeRange, "select min($__time(time_column))") - So(err, ShouldBeNil) - - So(sql, ShouldEqual, "select min(time_column AS \"time\")") - }) - - Convey("interpolate __timeFilter function", func() { - sql, err := engine.Interpolate(query, timeRange, "WHERE $__timeFilter(time_column)") - So(err, ShouldBeNil) - - So(sql, ShouldEqual, fmt.Sprintf("WHERE time_column BETWEEN '%s' AND '%s'", from.Format(time.RFC3339Nano), to.Format(time.RFC3339Nano))) - }) - - Convey("interpolate __timeFrom function", func() { - sql, err := engine.Interpolate(query, timeRange, "select $__timeFrom()") - So(err, ShouldBeNil) - - So(sql, ShouldEqual, "select '2018-04-12T18:00:00Z'") - }) - - Convey("interpolate __timeTo function", func() { - sql, err := engine.Interpolate(query, timeRange, "select $__timeTo()") - So(err, ShouldBeNil) - - So(sql, ShouldEqual, "select '2018-04-12T18:05:00Z'") - }) - - Convey("interpolate __timeGroup function pre 5.3 compatibility", func() { - sql, err := engine.Interpolate(query, timeRange, "SELECT $__timeGroup(time_column,'5m'), value") - So(err, ShouldBeNil) - - So(sql, ShouldEqual, "SELECT floor(extract(epoch from time_column)/300)*300 AS \"time\", value") - - sql, err = engine.Interpolate(query, timeRange, "SELECT $__timeGroup(time_column,'5m') as time, value") - So(err, ShouldBeNil) - - So(sql, ShouldEqual, "SELECT floor(extract(epoch from time_column)/300)*300 as time, value") - }) - - Convey("interpolate __timeGroup function", func() { - sql, err := engine.Interpolate(query, timeRange, "SELECT $__timeGroup(time_column,'5m')") - So(err, ShouldBeNil) - sql2, err := engine.Interpolate(query, timeRange, "SELECT $__timeGroupAlias(time_column,'5m')") - So(err, ShouldBeNil) - - So(sql, ShouldEqual, "SELECT floor(extract(epoch from time_column)/300)*300") - So(sql2, ShouldEqual, sql+" AS \"time\"") - }) - - Convey("interpolate __timeGroup function with spaces between args", func() { - sql, err := engine.Interpolate(query, timeRange, "$__timeGroup(time_column , '5m')") - So(err, ShouldBeNil) - sql2, err := engine.Interpolate(query, timeRange, "$__timeGroupAlias(time_column , '5m')") - So(err, ShouldBeNil) - - So(sql, ShouldEqual, "floor(extract(epoch from time_column)/300)*300") - So(sql2, ShouldEqual, sql+" AS \"time\"") - }) - - Convey("interpolate __timeGroup function with TimescaleDB enabled", func() { - sql, err := engineTS.Interpolate(query, timeRange, "GROUP BY $__timeGroup(time_column,'5m')") - So(err, ShouldBeNil) - - So(sql, ShouldEqual, "GROUP BY time_bucket('300s',time_column)") - }) - - Convey("interpolate __timeGroup function with spaces between args and TimescaleDB enabled", func() { - sql, err := engineTS.Interpolate(query, timeRange, "GROUP BY $__timeGroup(time_column , '5m')") - So(err, ShouldBeNil) - - So(sql, ShouldEqual, "GROUP BY time_bucket('300s',time_column)") - }) - - Convey("interpolate __timeGroup function with large time range as an argument and TimescaleDB enabled", func() { - sql, err := engineTS.Interpolate(query, timeRange, "GROUP BY $__timeGroup(time_column , '12d')") - So(err, ShouldBeNil) - - So(sql, ShouldEqual, "GROUP BY time_bucket('1036800s',time_column)") - }) - - Convey("interpolate __unixEpochFilter function", func() { - sql, err := engine.Interpolate(query, timeRange, "select $__unixEpochFilter(time)") - So(err, ShouldBeNil) - - So(sql, ShouldEqual, fmt.Sprintf("select time >= %d AND time <= %d", from.Unix(), to.Unix())) - }) - Convey("interpolate __unixEpochNanoFilter function", func() { - sql, err := engine.Interpolate(query, timeRange, "select $__unixEpochNanoFilter(time)") - So(err, ShouldBeNil) - - So(sql, ShouldEqual, fmt.Sprintf("select time >= %d AND time <= %d", from.UnixNano(), to.UnixNano())) - }) - Convey("interpolate __unixEpochNanoFrom function", func() { - sql, err := engine.Interpolate(query, timeRange, "select $__unixEpochNanoFrom()") - So(err, ShouldBeNil) - - So(sql, ShouldEqual, fmt.Sprintf("select %d", from.UnixNano())) - }) - - Convey("interpolate __unixEpochNanoTo function", func() { - sql, err := engine.Interpolate(query, timeRange, "select $__unixEpochNanoTo()") - So(err, ShouldBeNil) - - So(sql, ShouldEqual, fmt.Sprintf("select %d", to.UnixNano())) - }) - - Convey("interpolate __unixEpochGroup function", func() { - sql, err := engine.Interpolate(query, timeRange, "SELECT $__unixEpochGroup(time_column,'5m')") - So(err, ShouldBeNil) - sql2, err := engine.Interpolate(query, timeRange, "SELECT $__unixEpochGroupAlias(time_column,'5m')") - So(err, ShouldBeNil) - - So(sql, ShouldEqual, "SELECT floor(time_column/300)*300") - So(sql2, ShouldEqual, sql+" AS \"time\"") - }) + t.Run("interpolate __time function", func(t *testing.T) { + sql, err := engine.Interpolate(query, timeRange, "select $__time(time_column)") + require.NoError(t, err) + require.Equal(t, "select time_column AS \"time\"", sql) }) - Convey("Given a time range between 1960-02-01 07:00 and 1965-02-03 08:00", func() { - from := time.Date(1960, 2, 1, 7, 0, 0, 0, time.UTC) - to := time.Date(1965, 2, 3, 8, 0, 0, 0, time.UTC) - timeRange := plugins.NewDataTimeRange( - strconv.FormatInt(from.UnixNano()/int64(time.Millisecond), 10), - strconv.FormatInt(to.UnixNano()/int64(time.Millisecond), 10)) + t.Run("interpolate __time function wrapped in aggregation", func(t *testing.T) { + sql, err := engine.Interpolate(query, timeRange, "select min($__time(time_column))") + require.NoError(t, err) - Convey("interpolate __timeFilter function", func() { - sql, err := engine.Interpolate(query, timeRange, "WHERE $__timeFilter(time_column)") - So(err, ShouldBeNil) - - So(sql, ShouldEqual, fmt.Sprintf("WHERE time_column BETWEEN '%s' AND '%s'", from.Format(time.RFC3339Nano), to.Format(time.RFC3339Nano))) - }) - - Convey("interpolate __unixEpochFilter function", func() { - sql, err := engine.Interpolate(query, timeRange, "select $__unixEpochFilter(time)") - So(err, ShouldBeNil) - - So(sql, ShouldEqual, fmt.Sprintf("select time >= %d AND time <= %d", from.Unix(), to.Unix())) - }) - Convey("interpolate __unixEpochNanoFilter function", func() { - sql, err := engine.Interpolate(query, timeRange, "select $__unixEpochNanoFilter(time)") - So(err, ShouldBeNil) - - So(sql, ShouldEqual, fmt.Sprintf("select time >= %d AND time <= %d", from.UnixNano(), to.UnixNano())) - }) + require.Equal(t, "select min(time_column AS \"time\")", sql) }) - Convey("Given a time range between 1960-02-01 07:00 and 1980-02-03 08:00", func() { - from := time.Date(1960, 2, 1, 7, 0, 0, 0, time.UTC) - to := time.Date(1980, 2, 3, 8, 0, 0, 0, time.UTC) - timeRange := plugins.NewDataTimeRange( - strconv.FormatInt(from.UnixNano()/int64(time.Millisecond), 10), - strconv.FormatInt(to.UnixNano()/int64(time.Millisecond), 10)) + t.Run("interpolate __timeFilter function", func(t *testing.T) { + sql, err := engine.Interpolate(query, timeRange, "WHERE $__timeFilter(time_column)") + require.NoError(t, err) - Convey("interpolate __timeFilter function", func() { - sql, err := engine.Interpolate(query, timeRange, "WHERE $__timeFilter(time_column)") - So(err, ShouldBeNil) - - So(sql, ShouldEqual, fmt.Sprintf("WHERE time_column BETWEEN '%s' AND '%s'", from.Format(time.RFC3339Nano), to.Format(time.RFC3339Nano))) - }) - - Convey("interpolate __unixEpochFilter function", func() { - sql, err := engine.Interpolate(query, timeRange, "select $__unixEpochFilter(time)") - So(err, ShouldBeNil) - - So(sql, ShouldEqual, fmt.Sprintf("select time >= %d AND time <= %d", from.Unix(), to.Unix())) - }) - Convey("interpolate __unixEpochNanoFilter function", func() { - sql, err := engine.Interpolate(query, timeRange, "select $__unixEpochNanoFilter(time)") - So(err, ShouldBeNil) - - So(sql, ShouldEqual, fmt.Sprintf("select time >= %d AND time <= %d", from.UnixNano(), to.UnixNano())) - }) + require.Equal(t, fmt.Sprintf("WHERE time_column BETWEEN '%s' AND '%s'", from.Format(time.RFC3339Nano), to.Format(time.RFC3339Nano)), sql) }) - Convey("Given a time range between 1960-02-01 07:00:00.5 and 1980-02-03 08:00:00.5", func() { - from := time.Date(1960, 2, 1, 7, 0, 0, 500e6, time.UTC) - to := time.Date(1980, 2, 3, 8, 0, 0, 500e6, time.UTC) - timeRange := plugins.NewDataTimeRange( - strconv.FormatInt(from.UnixNano()/int64(time.Millisecond), 10), strconv.FormatInt(to.UnixNano()/int64(time.Millisecond), 10)) + t.Run("interpolate __timeFrom function", func(t *testing.T) { + sql, err := engine.Interpolate(query, timeRange, "select $__timeFrom()") + require.NoError(t, err) - So(from.Format(time.RFC3339Nano), ShouldEqual, "1960-02-01T07:00:00.5Z") - So(to.Format(time.RFC3339Nano), ShouldEqual, "1980-02-03T08:00:00.5Z") - Convey("interpolate __timeFilter function", func() { - sql, err := engine.Interpolate(query, timeRange, "WHERE $__timeFilter(time_column)") - So(err, ShouldBeNil) + require.Equal(t, "select '2018-04-12T18:00:00Z'", sql) + }) - So(sql, ShouldEqual, fmt.Sprintf("WHERE time_column BETWEEN '%s' AND '%s'", from.Format(time.RFC3339Nano), to.Format(time.RFC3339Nano))) - }) + t.Run("interpolate __timeTo function", func(t *testing.T) { + sql, err := engine.Interpolate(query, timeRange, "select $__timeTo()") + require.NoError(t, err) + + require.Equal(t, "select '2018-04-12T18:05:00Z'", sql) + }) + + t.Run("interpolate __timeGroup function pre 5.3 compatibility", func(t *testing.T) { + sql, err := engine.Interpolate(query, timeRange, "SELECT $__timeGroup(time_column,'5m'), value") + require.NoError(t, err) + + require.Equal(t, "SELECT floor(extract(epoch from time_column)/300)*300 AS \"time\", value", sql) + + sql, err = engine.Interpolate(query, timeRange, "SELECT $__timeGroup(time_column,'5m') as time, value") + require.NoError(t, err) + + require.Equal(t, "SELECT floor(extract(epoch from time_column)/300)*300 as time, value", sql) + }) + + t.Run("interpolate __timeGroup function", func(t *testing.T) { + sql, err := engine.Interpolate(query, timeRange, "SELECT $__timeGroup(time_column,'5m')") + require.NoError(t, err) + sql2, err := engine.Interpolate(query, timeRange, "SELECT $__timeGroupAlias(time_column,'5m')") + require.NoError(t, err) + + require.Equal(t, "SELECT floor(extract(epoch from time_column)/300)*300", sql) + require.Equal(t, sql2, sql+" AS \"time\"") + }) + + t.Run("interpolate __timeGroup function with spaces between args", func(t *testing.T) { + sql, err := engine.Interpolate(query, timeRange, "$__timeGroup(time_column , '5m')") + require.NoError(t, err) + sql2, err := engine.Interpolate(query, timeRange, "$__timeGroupAlias(time_column , '5m')") + require.NoError(t, err) + + require.Equal(t, "floor(extract(epoch from time_column)/300)*300", sql) + require.Equal(t, sql2, sql+" AS \"time\"") + }) + + t.Run("interpolate __timeGroup function with TimescaleDB enabled", func(t *testing.T) { + sql, err := engineTS.Interpolate(query, timeRange, "GROUP BY $__timeGroup(time_column,'5m')") + require.NoError(t, err) + require.Equal(t, "GROUP BY time_bucket('300.0s',time_column)", sql) + }) + + t.Run("interpolate __timeGroup function with spaces between args and TimescaleDB enabled", func(t *testing.T) { + sql, err := engineTS.Interpolate(query, timeRange, "GROUP BY $__timeGroup(time_column , '5m')") + require.NoError(t, err) + require.Equal(t, "GROUP BY time_bucket('300.0s',time_column)", sql) + }) + + t.Run("interpolate __timeGroup function with large time range as an argument and TimescaleDB enabled", func(t *testing.T) { + sql, err := engineTS.Interpolate(query, timeRange, "GROUP BY $__timeGroup(time_column , '12d')") + require.NoError(t, err) + require.Equal(t, "GROUP BY time_bucket('1036800.0s',time_column)", sql) + }) + + t.Run("interpolate __timeGroup function with small time range as an argument and TimescaleDB enabled", func(t *testing.T) { + sql, err := engineTS.Interpolate(query, timeRange, "GROUP BY $__timeGroup(time_column , '200ms')") + require.NoError(t, err) + require.Equal(t, "GROUP BY time_bucket('0.2s',time_column)", sql) + }) + + t.Run("interpolate __unixEpochFilter function", func(t *testing.T) { + sql, err := engine.Interpolate(query, timeRange, "select $__unixEpochFilter(time)") + require.NoError(t, err) + require.Equal(t, fmt.Sprintf("select time >= %d AND time <= %d", from.Unix(), to.Unix()), sql) + }) + + t.Run("interpolate __unixEpochNanoFilter function", func(t *testing.T) { + sql, err := engine.Interpolate(query, timeRange, "select $__unixEpochNanoFilter(time)") + require.NoError(t, err) + require.Equal(t, fmt.Sprintf("select time >= %d AND time <= %d", from.UnixNano(), to.UnixNano()), sql) + }) + + t.Run("interpolate __unixEpochNanoFrom function", func(t *testing.T) { + sql, err := engine.Interpolate(query, timeRange, "select $__unixEpochNanoFrom()") + require.NoError(t, err) + require.Equal(t, fmt.Sprintf("select %d", from.UnixNano()), sql) + }) + + t.Run("interpolate __unixEpochNanoTo function", func(t *testing.T) { + sql, err := engine.Interpolate(query, timeRange, "select $__unixEpochNanoTo()") + require.NoError(t, err) + require.Equal(t, fmt.Sprintf("select %d", to.UnixNano()), sql) + }) + + t.Run("interpolate __unixEpochGroup function", func(t *testing.T) { + sql, err := engine.Interpolate(query, timeRange, "SELECT $__unixEpochGroup(time_column,'5m')") + require.NoError(t, err) + sql2, err := engine.Interpolate(query, timeRange, "SELECT $__unixEpochGroupAlias(time_column,'5m')") + require.NoError(t, err) + require.Equal(t, "SELECT floor(time_column/300)*300", sql) + require.Equal(t, sql2, sql+" AS \"time\"") + }) + }) + + t.Run("Given a time range between 1960-02-01 07:00 and 1965-02-03 08:00", func(t *testing.T) { + from := time.Date(1960, 2, 1, 7, 0, 0, 0, time.UTC) + to := time.Date(1965, 2, 3, 8, 0, 0, 0, time.UTC) + timeRange := plugins.NewDataTimeRange( + strconv.FormatInt(from.UnixNano()/int64(time.Millisecond), 10), + strconv.FormatInt(to.UnixNano()/int64(time.Millisecond), 10)) + + t.Run("interpolate __timeFilter function", func(t *testing.T) { + sql, err := engine.Interpolate(query, timeRange, "WHERE $__timeFilter(time_column)") + require.NoError(t, err) + require.Equal(t, fmt.Sprintf("WHERE time_column BETWEEN '%s' AND '%s'", from.Format(time.RFC3339Nano), to.Format(time.RFC3339Nano)), sql) + }) + + t.Run("interpolate __unixEpochFilter function", func(t *testing.T) { + sql, err := engine.Interpolate(query, timeRange, "select $__unixEpochFilter(time)") + require.NoError(t, err) + require.Equal(t, fmt.Sprintf("select time >= %d AND time <= %d", from.Unix(), to.Unix()), sql) + }) + + t.Run("interpolate __unixEpochNanoFilter function", func(t *testing.T) { + sql, err := engine.Interpolate(query, timeRange, "select $__unixEpochNanoFilter(time)") + require.NoError(t, err) + require.Equal(t, fmt.Sprintf("select time >= %d AND time <= %d", from.UnixNano(), to.UnixNano()), sql) + }) + }) + + t.Run("Given a time range between 1960-02-01 07:00 and 1980-02-03 08:00", func(t *testing.T) { + from := time.Date(1960, 2, 1, 7, 0, 0, 0, time.UTC) + to := time.Date(1980, 2, 3, 8, 0, 0, 0, time.UTC) + timeRange := plugins.NewDataTimeRange( + strconv.FormatInt(from.UnixNano()/int64(time.Millisecond), 10), + strconv.FormatInt(to.UnixNano()/int64(time.Millisecond), 10)) + + t.Run("interpolate __timeFilter function", func(t *testing.T) { + sql, err := engine.Interpolate(query, timeRange, "WHERE $__timeFilter(time_column)") + require.NoError(t, err) + require.Equal(t, fmt.Sprintf("WHERE time_column BETWEEN '%s' AND '%s'", from.Format(time.RFC3339Nano), to.Format(time.RFC3339Nano)), sql) + }) + + t.Run("interpolate __unixEpochFilter function", func(t *testing.T) { + sql, err := engine.Interpolate(query, timeRange, "select $__unixEpochFilter(time)") + require.NoError(t, err) + require.Equal(t, fmt.Sprintf("select time >= %d AND time <= %d", from.Unix(), to.Unix()), sql) + }) + + t.Run("interpolate __unixEpochNanoFilter function", func(t *testing.T) { + sql, err := engine.Interpolate(query, timeRange, "select $__unixEpochNanoFilter(time)") + require.NoError(t, err) + require.Equal(t, fmt.Sprintf("select time >= %d AND time <= %d", from.UnixNano(), to.UnixNano()), sql) + }) + }) + + t.Run("Given a time range between 1960-02-01 07:00:00.5 and 1980-02-03 08:00:00.5", func(t *testing.T) { + from := time.Date(1960, 2, 1, 7, 0, 0, 500e6, time.UTC) + to := time.Date(1980, 2, 3, 8, 0, 0, 500e6, time.UTC) + timeRange := plugins.NewDataTimeRange( + strconv.FormatInt(from.UnixNano()/int64(time.Millisecond), 10), strconv.FormatInt(to.UnixNano()/int64(time.Millisecond), 10)) + + require.Equal(t, "1960-02-01T07:00:00.5Z", from.Format(time.RFC3339Nano)) + require.Equal(t, "1980-02-03T08:00:00.5Z", to.Format(time.RFC3339Nano)) + + t.Run("interpolate __timeFilter function", func(t *testing.T) { + sql, err := engine.Interpolate(query, timeRange, "WHERE $__timeFilter(time_column)") + require.NoError(t, err) + require.Equal(t, fmt.Sprintf("WHERE time_column BETWEEN '%s' AND '%s'", from.Format(time.RFC3339Nano), to.Format(time.RFC3339Nano)), sql) }) }) }