Introduce TSDB service (#31520)

* Introduce TSDB service

Signed-off-by: Arve Knudsen <arve.knudsen@gmail.com>

Co-authored-by: Erik Sundell <erik.sundell87@gmail.com>
Co-authored-by: Will Browne <will.browne@grafana.com>
Co-authored-by: Torkel Ödegaard <torkel@grafana.org>
Co-authored-by: Will Browne <wbrowne@users.noreply.github.com>
Co-authored-by: Zoltán Bedi <zoltan.bedi@gmail.com>
This commit is contained in:
Arve Knudsen
2021-03-08 07:02:49 +01:00
committed by GitHub
parent c899bf3592
commit b79e61656a
203 changed files with 5270 additions and 4777 deletions

View File

@ -14,10 +14,10 @@ import (
"github.com/grafana/grafana/pkg/components/simplejson"
"github.com/grafana/grafana/pkg/infra/log"
"github.com/grafana/grafana/pkg/models"
"github.com/grafana/grafana/pkg/plugins"
"github.com/grafana/grafana/pkg/services/sqlstore"
"github.com/grafana/grafana/pkg/services/sqlstore/sqlutil"
"github.com/grafana/grafana/pkg/setting"
"github.com/grafana/grafana/pkg/tsdb"
"github.com/grafana/grafana/pkg/tsdb/sqleng"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
@ -113,7 +113,7 @@ func TestGenerateConnectionString(t *testing.T) {
}
for _, tt := range testCases {
t.Run(tt.desc, func(t *testing.T) {
svc := postgresService{
svc := PostgresService{
Cfg: cfg,
logger: log.New("tsdb.postgres"),
tlsManager: &tlsTestManager{settings: tt.tlsSettings},
@ -169,19 +169,19 @@ func TestPostgres(t *testing.T) {
sqleng.NewXormEngine = func(d, c string) (*xorm.Engine, error) {
return x, nil
}
sqleng.Interpolate = func(query *tsdb.Query, timeRange *tsdb.TimeRange, sql string) (string, error) {
sqleng.Interpolate = func(query plugins.DataSubQuery, timeRange plugins.DataTimeRange, sql string) (string, error) {
return sql, nil
}
cfg := setting.NewCfg()
cfg.DataPath = t.TempDir()
svc := postgresService{
svc := PostgresService{
Cfg: cfg,
logger: log.New("tsdb.postgres"),
tlsManager: &tlsTestManager{settings: tlsSettings{Mode: "disable"}},
}
endpoint, err := svc.newPostgresQueryEndpoint(&models.DataSource{
exe, err := svc.NewExecutor(&models.DataSource{
JsonData: simplejson.New(),
SecureJsonData: securejsondata.SecureJsonData{},
})
@ -233,19 +233,19 @@ func TestPostgres(t *testing.T) {
require.NoError(t, err)
t.Run("When doing a table query should map Postgres column types to Go types", func(t *testing.T) {
query := &tsdb.TsdbQuery{
Queries: []*tsdb.Query{
query := plugins.DataQuery{
Queries: []plugins.DataSubQuery{
{
Model: simplejson.NewFromAny(map[string]interface{}{
"rawSql": "SELECT * FROM postgres_types",
"format": "table",
}),
RefId: "A",
RefID: "A",
},
},
}
resp, err := endpoint.Query(context.Background(), nil, query)
resp, err := exe.DataQuery(context.Background(), nil, query)
require.NoError(t, err)
queryResult := resp.Results["A"]
require.NoError(t, queryResult.Error)
@ -318,19 +318,19 @@ func TestPostgres(t *testing.T) {
require.NoError(t, err)
t.Run("When doing a metric query using timeGroup", func(t *testing.T) {
query := &tsdb.TsdbQuery{
Queries: []*tsdb.Query{
query := plugins.DataQuery{
Queries: []plugins.DataSubQuery{
{
Model: simplejson.NewFromAny(map[string]interface{}{
"rawSql": "SELECT $__timeGroup(time, '5m') AS time, avg(value) as value FROM metric GROUP BY 1 ORDER BY 1",
"format": "time_series",
}),
RefId: "A",
RefID: "A",
},
},
}
resp, err := endpoint.Query(context.Background(), nil, query)
resp, err := exe.DataQuery(context.Background(), nil, query)
require.NoError(t, err)
queryResult := resp.Results["A"]
require.NoError(t, queryResult.Error)
@ -368,24 +368,24 @@ func TestPostgres(t *testing.T) {
sqleng.Interpolate = mockInterpolate
})
query := &tsdb.TsdbQuery{
Queries: []*tsdb.Query{
query := plugins.DataQuery{
Queries: []plugins.DataSubQuery{
{
DataSource: &models.DataSource{},
Model: simplejson.NewFromAny(map[string]interface{}{
"rawSql": "SELECT $__timeGroup(time, $__interval) AS time, avg(value) as value FROM metric GROUP BY 1 ORDER BY 1",
"format": "time_series",
}),
RefId: "A",
RefID: "A",
},
},
TimeRange: &tsdb.TimeRange{
TimeRange: &plugins.DataTimeRange{
From: fmt.Sprintf("%v", fromStart.Unix()*1000),
To: fmt.Sprintf("%v", fromStart.Add(30*time.Minute).Unix()*1000),
},
}
resp, err := endpoint.Query(context.Background(), nil, query)
resp, err := exe.DataQuery(context.Background(), nil, query)
require.NoError(t, err)
queryResult := resp.Results["A"]
require.NoError(t, queryResult.Error)
@ -395,23 +395,23 @@ func TestPostgres(t *testing.T) {
})
t.Run("When doing a metric query using timeGroup with NULL fill enabled", func(t *testing.T) {
query := &tsdb.TsdbQuery{
Queries: []*tsdb.Query{
query := plugins.DataQuery{
Queries: []plugins.DataSubQuery{
{
Model: simplejson.NewFromAny(map[string]interface{}{
"rawSql": "SELECT $__timeGroup(time, '5m', NULL) AS time, avg(value) as value FROM metric GROUP BY 1 ORDER BY 1",
"format": "time_series",
}),
RefId: "A",
RefID: "A",
},
},
TimeRange: &tsdb.TimeRange{
TimeRange: &plugins.DataTimeRange{
From: fmt.Sprintf("%v", fromStart.Unix()*1000),
To: fmt.Sprintf("%v", fromStart.Add(34*time.Minute).Unix()*1000),
},
}
resp, err := endpoint.Query(context.Background(), nil, query)
resp, err := exe.DataQuery(context.Background(), nil, query)
require.NoError(t, err)
queryResult := resp.Results["A"]
require.NoError(t, queryResult.Error)
@ -448,23 +448,23 @@ func TestPostgres(t *testing.T) {
})
t.Run("When doing a metric query using timeGroup with value fill enabled", func(t *testing.T) {
query := &tsdb.TsdbQuery{
Queries: []*tsdb.Query{
query := plugins.DataQuery{
Queries: []plugins.DataSubQuery{
{
Model: simplejson.NewFromAny(map[string]interface{}{
"rawSql": "SELECT $__timeGroup(time, '5m', 1.5) AS time, avg(value) as value FROM metric GROUP BY 1 ORDER BY 1",
"format": "time_series",
}),
RefId: "A",
RefID: "A",
},
},
TimeRange: &tsdb.TimeRange{
TimeRange: &plugins.DataTimeRange{
From: fmt.Sprintf("%v", fromStart.Unix()*1000),
To: fmt.Sprintf("%v", fromStart.Add(34*time.Minute).Unix()*1000),
},
}
resp, err := endpoint.Query(context.Background(), nil, query)
resp, err := exe.DataQuery(context.Background(), nil, query)
require.NoError(t, err)
queryResult := resp.Results["A"]
require.NoError(t, queryResult.Error)
@ -475,23 +475,23 @@ func TestPostgres(t *testing.T) {
})
t.Run("When doing a metric query using timeGroup with previous fill enabled", func(t *testing.T) {
query := &tsdb.TsdbQuery{
Queries: []*tsdb.Query{
query := plugins.DataQuery{
Queries: []plugins.DataSubQuery{
{
Model: simplejson.NewFromAny(map[string]interface{}{
"rawSql": "SELECT $__timeGroup(time, '5m', previous), avg(value) as value FROM metric GROUP BY 1 ORDER BY 1",
"format": "time_series",
}),
RefId: "A",
RefID: "A",
},
},
TimeRange: &tsdb.TimeRange{
TimeRange: &plugins.DataTimeRange{
From: fmt.Sprintf("%v", fromStart.Unix()*1000),
To: fmt.Sprintf("%v", fromStart.Add(34*time.Minute).Unix()*1000),
},
}
resp, err := endpoint.Query(context.Background(), nil, query)
resp, err := exe.DataQuery(context.Background(), nil, query)
require.NoError(t, err)
queryResult := resp.Results["A"]
require.NoError(t, queryResult.Error)
@ -572,19 +572,19 @@ func TestPostgres(t *testing.T) {
t.Run(
"When doing a metric query using epoch (int64) as time column and value column (int64) should return metric with time in milliseconds",
func(t *testing.T) {
query := &tsdb.TsdbQuery{
Queries: []*tsdb.Query{
query := plugins.DataQuery{
Queries: []plugins.DataSubQuery{
{
Model: simplejson.NewFromAny(map[string]interface{}{
"rawSql": `SELECT "timeInt64" as time, "timeInt64" FROM metric_values ORDER BY time LIMIT 1`,
"format": "time_series",
}),
RefId: "A",
RefID: "A",
},
},
}
resp, err := endpoint.Query(context.Background(), nil, query)
resp, err := exe.DataQuery(context.Background(), nil, query)
require.NoError(t, err)
queryResult := resp.Results["A"]
require.NoError(t, queryResult.Error)
@ -595,19 +595,19 @@ func TestPostgres(t *testing.T) {
t.Run("When doing a metric query using epoch (int64 nullable) as time column and value column (int64 nullable,) should return metric with time in milliseconds",
func(t *testing.T) {
query := &tsdb.TsdbQuery{
Queries: []*tsdb.Query{
query := plugins.DataQuery{
Queries: []plugins.DataSubQuery{
{
Model: simplejson.NewFromAny(map[string]interface{}{
"rawSql": `SELECT "timeInt64Nullable" as time, "timeInt64Nullable" FROM metric_values ORDER BY time LIMIT 1`,
"format": "time_series",
}),
RefId: "A",
RefID: "A",
},
},
}
resp, err := endpoint.Query(context.Background(), nil, query)
resp, err := exe.DataQuery(context.Background(), nil, query)
require.NoError(t, err)
queryResult := resp.Results["A"]
require.NoError(t, queryResult.Error)
@ -618,19 +618,19 @@ func TestPostgres(t *testing.T) {
t.Run("When doing a metric query using epoch (float64) as time column and value column (float64), should return metric with time in milliseconds",
func(t *testing.T) {
query := &tsdb.TsdbQuery{
Queries: []*tsdb.Query{
query := plugins.DataQuery{
Queries: []plugins.DataSubQuery{
{
Model: simplejson.NewFromAny(map[string]interface{}{
"rawSql": `SELECT "timeFloat64" as time, "timeFloat64" FROM metric_values ORDER BY time LIMIT 1`,
"format": "time_series",
}),
RefId: "A",
RefID: "A",
},
},
}
resp, err := endpoint.Query(context.Background(), nil, query)
resp, err := exe.DataQuery(context.Background(), nil, query)
require.NoError(t, err)
queryResult := resp.Results["A"]
require.NoError(t, queryResult.Error)
@ -641,19 +641,19 @@ func TestPostgres(t *testing.T) {
t.Run("When doing a metric query using epoch (float64 nullable) as time column and value column (float64 nullable), should return metric with time in milliseconds",
func(t *testing.T) {
query := &tsdb.TsdbQuery{
Queries: []*tsdb.Query{
query := plugins.DataQuery{
Queries: []plugins.DataSubQuery{
{
Model: simplejson.NewFromAny(map[string]interface{}{
"rawSql": `SELECT "timeFloat64Nullable" as time, "timeFloat64Nullable" FROM metric_values ORDER BY time LIMIT 1`,
"format": "time_series",
}),
RefId: "A",
RefID: "A",
},
},
}
resp, err := endpoint.Query(context.Background(), nil, query)
resp, err := exe.DataQuery(context.Background(), nil, query)
require.NoError(t, err)
queryResult := resp.Results["A"]
require.NoError(t, queryResult.Error)
@ -664,19 +664,19 @@ func TestPostgres(t *testing.T) {
t.Run("When doing a metric query using epoch (int32) as time column and value column (int32), should return metric with time in milliseconds",
func(t *testing.T) {
query := &tsdb.TsdbQuery{
Queries: []*tsdb.Query{
query := plugins.DataQuery{
Queries: []plugins.DataSubQuery{
{
Model: simplejson.NewFromAny(map[string]interface{}{
"rawSql": `SELECT "timeInt32" as time, "timeInt32" FROM metric_values ORDER BY time LIMIT 1`,
"format": "time_series",
}),
RefId: "A",
RefID: "A",
},
},
}
resp, err := endpoint.Query(context.Background(), nil, query)
resp, err := exe.DataQuery(context.Background(), nil, query)
require.NoError(t, err)
queryResult := resp.Results["A"]
require.NoError(t, queryResult.Error)
@ -687,19 +687,19 @@ func TestPostgres(t *testing.T) {
t.Run("When doing a metric query using epoch (int32 nullable) as time column and value column (int32 nullable), should return metric with time in milliseconds",
func(t *testing.T) {
query := &tsdb.TsdbQuery{
Queries: []*tsdb.Query{
query := plugins.DataQuery{
Queries: []plugins.DataSubQuery{
{
Model: simplejson.NewFromAny(map[string]interface{}{
"rawSql": `SELECT "timeInt32Nullable" as time, "timeInt32Nullable" FROM metric_values ORDER BY time LIMIT 1`,
"format": "time_series",
}),
RefId: "A",
RefID: "A",
},
},
}
resp, err := endpoint.Query(context.Background(), nil, query)
resp, err := exe.DataQuery(context.Background(), nil, query)
require.NoError(t, err)
queryResult := resp.Results["A"]
require.NoError(t, queryResult.Error)
@ -710,19 +710,19 @@ func TestPostgres(t *testing.T) {
t.Run("When doing a metric query using epoch (float32) as time column and value column (float32), should return metric with time in milliseconds",
func(t *testing.T) {
query := &tsdb.TsdbQuery{
Queries: []*tsdb.Query{
query := plugins.DataQuery{
Queries: []plugins.DataSubQuery{
{
Model: simplejson.NewFromAny(map[string]interface{}{
"rawSql": `SELECT "timeFloat32" as time, "timeFloat32" FROM metric_values ORDER BY time LIMIT 1`,
"format": "time_series",
}),
RefId: "A",
RefID: "A",
},
},
}
resp, err := endpoint.Query(context.Background(), nil, query)
resp, err := exe.DataQuery(context.Background(), nil, query)
require.NoError(t, err)
queryResult := resp.Results["A"]
require.NoError(t, queryResult.Error)
@ -733,19 +733,19 @@ func TestPostgres(t *testing.T) {
t.Run("When doing a metric query using epoch (float32 nullable) as time column and value column (float32 nullable), should return metric with time in milliseconds",
func(t *testing.T) {
query := &tsdb.TsdbQuery{
Queries: []*tsdb.Query{
query := plugins.DataQuery{
Queries: []plugins.DataSubQuery{
{
Model: simplejson.NewFromAny(map[string]interface{}{
"rawSql": `SELECT "timeFloat32Nullable" as time, "timeFloat32Nullable" FROM metric_values ORDER BY time LIMIT 1`,
"format": "time_series",
}),
RefId: "A",
RefID: "A",
},
},
}
resp, err := endpoint.Query(context.Background(), nil, query)
resp, err := exe.DataQuery(context.Background(), nil, query)
require.NoError(t, err)
queryResult := resp.Results["A"]
require.NoError(t, queryResult.Error)
@ -755,19 +755,19 @@ func TestPostgres(t *testing.T) {
})
t.Run("When doing a metric query grouping by time and select metric column should return correct series", func(t *testing.T) {
query := &tsdb.TsdbQuery{
Queries: []*tsdb.Query{
query := plugins.DataQuery{
Queries: []plugins.DataSubQuery{
{
Model: simplejson.NewFromAny(map[string]interface{}{
"rawSql": `SELECT $__timeEpoch(time), measurement || ' - value one' as metric, "valueOne" FROM metric_values ORDER BY 1`,
"format": "time_series",
}),
RefId: "A",
RefID: "A",
},
},
}
resp, err := endpoint.Query(context.Background(), nil, query)
resp, err := exe.DataQuery(context.Background(), nil, query)
require.NoError(t, err)
queryResult := resp.Results["A"]
require.NoError(t, queryResult.Error)
@ -778,19 +778,19 @@ func TestPostgres(t *testing.T) {
})
t.Run("When doing a metric query with metric column and multiple value columns", func(t *testing.T) {
query := &tsdb.TsdbQuery{
Queries: []*tsdb.Query{
query := plugins.DataQuery{
Queries: []plugins.DataSubQuery{
{
Model: simplejson.NewFromAny(map[string]interface{}{
"rawSql": `SELECT $__timeEpoch(time), measurement as metric, "valueOne", "valueTwo" FROM metric_values ORDER BY 1`,
"format": "time_series",
}),
RefId: "A",
RefID: "A",
},
},
}
resp, err := endpoint.Query(context.Background(), nil, query)
resp, err := exe.DataQuery(context.Background(), nil, query)
require.NoError(t, err)
queryResult := resp.Results["A"]
require.NoError(t, queryResult.Error)
@ -803,19 +803,19 @@ func TestPostgres(t *testing.T) {
})
t.Run("When doing a metric query grouping by time should return correct series", func(t *testing.T) {
query := &tsdb.TsdbQuery{
Queries: []*tsdb.Query{
query := plugins.DataQuery{
Queries: []plugins.DataSubQuery{
{
Model: simplejson.NewFromAny(map[string]interface{}{
"rawSql": `SELECT $__timeEpoch(time), "valueOne", "valueTwo" FROM metric_values ORDER BY 1`,
"format": "time_series",
}),
RefId: "A",
RefID: "A",
},
},
}
resp, err := endpoint.Query(context.Background(), nil, query)
resp, err := exe.DataQuery(context.Background(), nil, query)
require.NoError(t, err)
queryResult := resp.Results["A"]
require.NoError(t, queryResult.Error)
@ -832,21 +832,21 @@ func TestPostgres(t *testing.T) {
})
sqleng.Interpolate = origInterpolate
query := &tsdb.TsdbQuery{
TimeRange: tsdb.NewFakeTimeRange("5m", "now", fromStart),
Queries: []*tsdb.Query{
query := plugins.DataQuery{
TimeRange: &plugins.DataTimeRange{From: "5m", To: "now", Now: fromStart},
Queries: []plugins.DataSubQuery{
{
DataSource: &models.DataSource{JsonData: simplejson.New()},
Model: simplejson.NewFromAny(map[string]interface{}{
"rawSql": `SELECT time FROM metric_values WHERE time > $__timeFrom() OR time < $__timeFrom() OR 1 < $__unixEpochFrom() OR $__unixEpochTo() > 1 ORDER BY 1`,
"format": "time_series",
}),
RefId: "A",
RefID: "A",
},
},
}
resp, err := endpoint.Query(context.Background(), nil, query)
resp, err := exe.DataQuery(context.Background(), nil, query)
require.NoError(t, err)
queryResult := resp.Results["A"]
require.NoError(t, queryResult.Error)
@ -891,46 +891,46 @@ func TestPostgres(t *testing.T) {
}
t.Run("When doing an annotation query of deploy events should return expected result", func(t *testing.T) {
query := &tsdb.TsdbQuery{
Queries: []*tsdb.Query{
query := plugins.DataQuery{
Queries: []plugins.DataSubQuery{
{
Model: simplejson.NewFromAny(map[string]interface{}{
"rawSql": `SELECT "time_sec" as time, description as text, tags FROM event WHERE $__unixEpochFilter(time_sec) AND tags='deploy' ORDER BY 1 ASC`,
"format": "table",
}),
RefId: "Deploys",
RefID: "Deploys",
},
},
TimeRange: &tsdb.TimeRange{
TimeRange: &plugins.DataTimeRange{
From: fmt.Sprintf("%v", fromStart.Add(-20*time.Minute).Unix()*1000),
To: fmt.Sprintf("%v", fromStart.Add(40*time.Minute).Unix()*1000),
},
}
resp, err := endpoint.Query(context.Background(), nil, query)
resp, err := exe.DataQuery(context.Background(), nil, query)
queryResult := resp.Results["Deploys"]
require.NoError(t, err)
require.Len(t, queryResult.Tables[0].Rows, 3)
})
t.Run("When doing an annotation query of ticket events should return expected result", func(t *testing.T) {
query := &tsdb.TsdbQuery{
Queries: []*tsdb.Query{
query := plugins.DataQuery{
Queries: []plugins.DataSubQuery{
{
Model: simplejson.NewFromAny(map[string]interface{}{
"rawSql": `SELECT "time_sec" as time, description as text, tags FROM event WHERE $__unixEpochFilter(time_sec) AND tags='ticket' ORDER BY 1 ASC`,
"format": "table",
}),
RefId: "Tickets",
RefID: "Tickets",
},
},
TimeRange: &tsdb.TimeRange{
TimeRange: &plugins.DataTimeRange{
From: fmt.Sprintf("%v", fromStart.Add(-20*time.Minute).Unix()*1000),
To: fmt.Sprintf("%v", fromStart.Add(40*time.Minute).Unix()*1000),
},
}
resp, err := endpoint.Query(context.Background(), nil, query)
resp, err := exe.DataQuery(context.Background(), nil, query)
queryResult := resp.Results["Tickets"]
require.NoError(t, err)
require.Len(t, queryResult.Tables[0].Rows, 3)
@ -940,8 +940,8 @@ func TestPostgres(t *testing.T) {
dt := time.Date(2018, 3, 14, 21, 20, 6, 527e6, time.UTC)
dtFormat := "2006-01-02 15:04:05.999999999"
query := &tsdb.TsdbQuery{
Queries: []*tsdb.Query{
query := plugins.DataQuery{
Queries: []plugins.DataSubQuery{
{
Model: simplejson.NewFromAny(map[string]interface{}{
"rawSql": fmt.Sprintf(`SELECT
@ -951,12 +951,12 @@ func TestPostgres(t *testing.T) {
`, dt.Format(dtFormat)),
"format": "table",
}),
RefId: "A",
RefID: "A",
},
},
}
resp, err := endpoint.Query(context.Background(), nil, query)
resp, err := exe.DataQuery(context.Background(), nil, query)
require.NoError(t, err)
queryResult := resp.Results["A"]
require.NoError(t, queryResult.Error)
@ -970,8 +970,8 @@ func TestPostgres(t *testing.T) {
t.Run("When doing an annotation query with a time column in epoch second format should return ms", func(t *testing.T) {
dt := time.Date(2018, 3, 14, 21, 20, 6, 527e6, time.UTC)
query := &tsdb.TsdbQuery{
Queries: []*tsdb.Query{
query := plugins.DataQuery{
Queries: []plugins.DataSubQuery{
{
Model: simplejson.NewFromAny(map[string]interface{}{
"rawSql": fmt.Sprintf(`SELECT
@ -981,12 +981,12 @@ func TestPostgres(t *testing.T) {
`, dt.Unix()),
"format": "table",
}),
RefId: "A",
RefID: "A",
},
},
}
resp, err := endpoint.Query(context.Background(), nil, query)
resp, err := exe.DataQuery(context.Background(), nil, query)
require.NoError(t, err)
queryResult := resp.Results["A"]
require.NoError(t, queryResult.Error)
@ -1000,8 +1000,8 @@ func TestPostgres(t *testing.T) {
t.Run("When doing an annotation query with a time column in epoch second format (t *testing.Tint) should return ms", func(t *testing.T) {
dt := time.Date(2018, 3, 14, 21, 20, 6, 527e6, time.UTC)
query := &tsdb.TsdbQuery{
Queries: []*tsdb.Query{
query := plugins.DataQuery{
Queries: []plugins.DataSubQuery{
{
Model: simplejson.NewFromAny(map[string]interface{}{
"rawSql": fmt.Sprintf(`SELECT
@ -1011,12 +1011,12 @@ func TestPostgres(t *testing.T) {
`, dt.Unix()),
"format": "table",
}),
RefId: "A",
RefID: "A",
},
},
}
resp, err := endpoint.Query(context.Background(), nil, query)
resp, err := exe.DataQuery(context.Background(), nil, query)
require.NoError(t, err)
queryResult := resp.Results["A"]
require.NoError(t, queryResult.Error)
@ -1030,8 +1030,8 @@ func TestPostgres(t *testing.T) {
t.Run("When doing an annotation query with a time column in epoch millisecond format should return ms", func(t *testing.T) {
dt := time.Date(2018, 3, 14, 21, 20, 6, 527e6, time.UTC)
query := &tsdb.TsdbQuery{
Queries: []*tsdb.Query{
query := plugins.DataQuery{
Queries: []plugins.DataSubQuery{
{
Model: simplejson.NewFromAny(map[string]interface{}{
"rawSql": fmt.Sprintf(`SELECT
@ -1041,12 +1041,12 @@ func TestPostgres(t *testing.T) {
`, dt.Unix()*1000),
"format": "table",
}),
RefId: "A",
RefID: "A",
},
},
}
resp, err := endpoint.Query(context.Background(), nil, query)
resp, err := exe.DataQuery(context.Background(), nil, query)
require.NoError(t, err)
queryResult := resp.Results["A"]
require.NoError(t, queryResult.Error)
@ -1058,8 +1058,8 @@ func TestPostgres(t *testing.T) {
})
t.Run("When doing an annotation query with a time column holding a bigint null value should return nil", func(t *testing.T) {
query := &tsdb.TsdbQuery{
Queries: []*tsdb.Query{
query := plugins.DataQuery{
Queries: []plugins.DataSubQuery{
{
Model: simplejson.NewFromAny(map[string]interface{}{
"rawSql": `SELECT
@ -1069,12 +1069,12 @@ func TestPostgres(t *testing.T) {
`,
"format": "table",
}),
RefId: "A",
RefID: "A",
},
},
}
resp, err := endpoint.Query(context.Background(), nil, query)
resp, err := exe.DataQuery(context.Background(), nil, query)
require.NoError(t, err)
queryResult := resp.Results["A"]
require.NoError(t, queryResult.Error)
@ -1086,8 +1086,8 @@ func TestPostgres(t *testing.T) {
})
t.Run("When doing an annotation query with a time column holding a timestamp null value should return nil", func(t *testing.T) {
query := &tsdb.TsdbQuery{
Queries: []*tsdb.Query{
query := plugins.DataQuery{
Queries: []plugins.DataSubQuery{
{
Model: simplejson.NewFromAny(map[string]interface{}{
"rawSql": `SELECT
@ -1097,12 +1097,12 @@ func TestPostgres(t *testing.T) {
`,
"format": "table",
}),
RefId: "A",
RefID: "A",
},
},
}
resp, err := endpoint.Query(context.Background(), nil, query)
resp, err := exe.DataQuery(context.Background(), nil, query)
require.NoError(t, err)
queryResult := resp.Results["A"]
require.NoError(t, queryResult.Error)