Refactor: Move sql_engine to sub package of tsdb (#18991)

this way importing the tsdb package does not come with xorm dependencies

pkg/tsdb/mssql/macros.go

@@ -8,19 +8,20 @@ import (
 
 	"github.com/grafana/grafana/pkg/components/gtime"
 	"github.com/grafana/grafana/pkg/tsdb"
+	"github.com/grafana/grafana/pkg/tsdb/sqleng"
 )
 
 const rsIdentifier = `([_a-zA-Z0-9]+)`
 const sExpr = `\$` + rsIdentifier + `\(([^\)]*)\)`
 
 type msSqlMacroEngine struct {
-	*tsdb.SqlMacroEngineBase
+	*sqleng.SqlMacroEngineBase
 	timeRange *tsdb.TimeRange
 	query     *tsdb.Query
 }
 
-func newMssqlMacroEngine() tsdb.SqlMacroEngine {
-	return &msSqlMacroEngine{SqlMacroEngineBase: tsdb.NewSqlMacroEngineBase()}
+func newMssqlMacroEngine() sqleng.SqlMacroEngine {
+	return &msSqlMacroEngine{SqlMacroEngineBase: sqleng.NewSqlMacroEngineBase()}
 }
 
 func (m *msSqlMacroEngine) Interpolate(query *tsdb.Query, timeRange *tsdb.TimeRange, sql string) (string, error) {
@@ -80,7 +81,7 @@ func (m *msSqlMacroEngine) evaluateMacro(name string, args []string) (string, er
 			return "", fmt.Errorf("error parsing interval %v", args[1])
 		}
 		if len(args) == 3 {
-			err := tsdb.SetupFillmode(m.query, interval, args[2])
+			err := sqleng.SetupFillmode(m.query, interval, args[2])
 			if err != nil {
 				return "", err
 			}
@@ -115,7 +116,7 @@ func (m *msSqlMacroEngine) evaluateMacro(name string, args []string) (string, er
 			return "", fmt.Errorf("error parsing interval %v", args[1])
 		}
 		if len(args) == 3 {
-			err := tsdb.SetupFillmode(m.query, interval, args[2])
+			err := sqleng.SetupFillmode(m.query, interval, args[2])
 			if err != nil {
 				return "", err
 			}

pkg/tsdb/mssql/mssql.go

@@ -3,15 +3,17 @@ package mssql
 import (
 	"database/sql"
 	"fmt"
-	"github.com/grafana/grafana/pkg/setting"
 	"net/url"
 	"strconv"
 
+	"github.com/grafana/grafana/pkg/setting"
+
 	_ "github.com/denisenkom/go-mssqldb"
 	"github.com/go-xorm/core"
 	"github.com/grafana/grafana/pkg/infra/log"
 	"github.com/grafana/grafana/pkg/models"
 	"github.com/grafana/grafana/pkg/tsdb"
+	"github.com/grafana/grafana/pkg/tsdb/sqleng"
 	"github.com/grafana/grafana/pkg/util"
 )
 
@@ -27,7 +29,7 @@ func newMssqlQueryEndpoint(datasource *models.DataSource) (tsdb.TsdbQueryEndpoin
 		logger.Debug("getEngine", "connection", cnnstr)
 	}
 
-	config := tsdb.SqlQueryEndpointConfiguration{
+	config := sqleng.SqlQueryEndpointConfiguration{
 		DriverName:        "mssql",
 		ConnectionString:  cnnstr,
 		Datasource:        datasource,
@@ -38,7 +40,7 @@ func newMssqlQueryEndpoint(datasource *models.DataSource) (tsdb.TsdbQueryEndpoin
 		log: logger,
 	}
 
-	return tsdb.NewSqlQueryEndpoint(&config, &rowTransformer, newMssqlMacroEngine(), logger)
+	return sqleng.NewSqlQueryEndpoint(&config, &rowTransformer, newMssqlMacroEngine(), logger)
 }
 
 func generateConnectionString(datasource *models.DataSource) string {

pkg/tsdb/mssql/mssql_test.go

@@ -14,6 +14,7 @@ import (
 	"github.com/grafana/grafana/pkg/models"
 	"github.com/grafana/grafana/pkg/services/sqlstore/sqlutil"
 	"github.com/grafana/grafana/pkg/tsdb"
+	"github.com/grafana/grafana/pkg/tsdb/sqleng"
 	. "github.com/smartystreets/goconvey/convey"
 )
 
@@ -58,13 +59,13 @@ func TestMSSQL(t *testing.T) {
 	SkipConvey("MSSQL", t, func() {
 		x := InitMSSQLTestDB(t)
 
-		origXormEngine := tsdb.NewXormEngine
-		tsdb.NewXormEngine = func(d, c string) (*xorm.Engine, error) {
+		origXormEngine := sqleng.NewXormEngine
+		sqleng.NewXormEngine = func(d, c string) (*xorm.Engine, error) {
 			return x, nil
 		}
 
-		origInterpolate := tsdb.Interpolate
-		tsdb.Interpolate = func(query *tsdb.Query, timeRange *tsdb.TimeRange, sql string) (string, error) {
+		origInterpolate := sqleng.Interpolate
+		sqleng.Interpolate = func(query *tsdb.Query, timeRange *tsdb.TimeRange, sql string) (string, error) {
 			return sql, nil
 		}
 
@@ -79,8 +80,8 @@ func TestMSSQL(t *testing.T) {
 
 		Reset(func() {
 			sess.Close()
-			tsdb.NewXormEngine = origXormEngine
-			tsdb.Interpolate = origInterpolate
+			sqleng.NewXormEngine = origXormEngine
+			sqleng.Interpolate = origInterpolate
 		})
 
 		Convey("Given a table with different native data types", func() {
@@ -330,11 +331,11 @@ func TestMSSQL(t *testing.T) {
 			})
 
 			Convey("When doing a metric query using timeGroup and $__interval", func() {
-				mockInterpolate := tsdb.Interpolate
-				tsdb.Interpolate = origInterpolate
+				mockInterpolate := sqleng.Interpolate
+				sqleng.Interpolate = origInterpolate
 
 				Reset(func() {
-					tsdb.Interpolate = mockInterpolate
+					sqleng.Interpolate = mockInterpolate
 				})
 
 				Convey("Should replace $__interval", func() {
@@ -704,7 +705,7 @@ func TestMSSQL(t *testing.T) {
 			})
 
 			Convey("When doing a query with timeFrom,timeTo,unixEpochFrom,unixEpochTo macros", func() {
-				tsdb.Interpolate = origInterpolate
+				sqleng.Interpolate = origInterpolate
 				query := &tsdb.TsdbQuery{
 					TimeRange: tsdb.NewFakeTimeRange("5m", "now", fromStart),
 					Queries: []*tsdb.Query{
@@ -771,7 +772,7 @@ func TestMSSQL(t *testing.T) {
 				So(err, ShouldBeNil)
 
 				Convey("When doing a metric query using stored procedure should return correct result", func() {
-					tsdb.Interpolate = origInterpolate
+					sqleng.Interpolate = origInterpolate
 					query := &tsdb.TsdbQuery{
 						Queries: []*tsdb.Query{
 							{
@@ -850,7 +851,7 @@ func TestMSSQL(t *testing.T) {
 				So(err, ShouldBeNil)
 
 				Convey("When doing a metric query using stored procedure should return correct result", func() {
-					tsdb.Interpolate = origInterpolate
+					sqleng.Interpolate = origInterpolate
 					query := &tsdb.TsdbQuery{
 						Queries: []*tsdb.Query{
 							{

pkg/tsdb/mysql/macros.go

@@ -7,19 +7,20 @@ import (
 
 	"github.com/grafana/grafana/pkg/components/gtime"
 	"github.com/grafana/grafana/pkg/tsdb"
+	"github.com/grafana/grafana/pkg/tsdb/sqleng"
 )
 
 const rsIdentifier = `([_a-zA-Z0-9]+)`
 const sExpr = `\$` + rsIdentifier + `\(([^\)]*)\)`
 
 type mySqlMacroEngine struct {
-	*tsdb.SqlMacroEngineBase
+	*sqleng.SqlMacroEngineBase
 	timeRange *tsdb.TimeRange
 	query     *tsdb.Query
 }
 
-func newMysqlMacroEngine() tsdb.SqlMacroEngine {
-	return &mySqlMacroEngine{SqlMacroEngineBase: tsdb.NewSqlMacroEngineBase()}
+func newMysqlMacroEngine() sqleng.SqlMacroEngine {
+	return &mySqlMacroEngine{SqlMacroEngineBase: sqleng.NewSqlMacroEngineBase()}
 }
 
 func (m *mySqlMacroEngine) Interpolate(query *tsdb.Query, timeRange *tsdb.TimeRange, sql string) (string, error) {
@@ -74,7 +75,7 @@ func (m *mySqlMacroEngine) evaluateMacro(name string, args []string) (string, er
 			return "", fmt.Errorf("error parsing interval %v", args[1])
 		}
 		if len(args) == 3 {
-			err := tsdb.SetupFillmode(m.query, interval, args[2])
+			err := sqleng.SetupFillmode(m.query, interval, args[2])
 			if err != nil {
 				return "", err
 			}
@@ -109,7 +110,7 @@ func (m *mySqlMacroEngine) evaluateMacro(name string, args []string) (string, er
 			return "", fmt.Errorf("error parsing interval %v", args[1])
 		}
 		if len(args) == 3 {
-			err := tsdb.SetupFillmode(m.query, interval, args[2])
+			err := sqleng.SetupFillmode(m.query, interval, args[2])
 			if err != nil {
 				return "", err
 			}

pkg/tsdb/mysql/mysql.go

@@ -3,16 +3,18 @@ package mysql
 import (
 	"database/sql"
 	"fmt"
-	"github.com/grafana/grafana/pkg/setting"
 	"reflect"
 	"strconv"
 	"strings"
 
+	"github.com/grafana/grafana/pkg/setting"
+
 	"github.com/go-sql-driver/mysql"
 	"github.com/go-xorm/core"
 	"github.com/grafana/grafana/pkg/infra/log"
 	"github.com/grafana/grafana/pkg/models"
 	"github.com/grafana/grafana/pkg/tsdb"
+	"github.com/grafana/grafana/pkg/tsdb/sqleng"
 )
 
 func init() {
@@ -49,7 +51,7 @@ func newMysqlQueryEndpoint(datasource *models.DataSource) (tsdb.TsdbQueryEndpoin
 		logger.Debug("getEngine", "connection", cnnstr)
 	}
 
-	config := tsdb.SqlQueryEndpointConfiguration{
+	config := sqleng.SqlQueryEndpointConfiguration{
 		DriverName:        "mysql",
 		ConnectionString:  cnnstr,
 		Datasource:        datasource,
@@ -61,7 +63,7 @@ func newMysqlQueryEndpoint(datasource *models.DataSource) (tsdb.TsdbQueryEndpoin
 		log: logger,
 	}
 
-	return tsdb.NewSqlQueryEndpoint(&config, &rowTransformer, newMysqlMacroEngine(), logger)
+	return sqleng.NewSqlQueryEndpoint(&config, &rowTransformer, newMysqlMacroEngine(), logger)
 }
 
 type mysqlRowTransformer struct {

pkg/tsdb/mysql/mysql_test.go

@@ -15,6 +15,8 @@ import (
 	"github.com/grafana/grafana/pkg/services/sqlstore"
 	"github.com/grafana/grafana/pkg/services/sqlstore/sqlutil"
 	"github.com/grafana/grafana/pkg/tsdb"
+	"github.com/grafana/grafana/pkg/tsdb/sqleng"
+
 	. "github.com/smartystreets/goconvey/convey"
 )
 
@@ -38,13 +40,13 @@ func TestMySQL(t *testing.T) {
 	Convey("MySQL", t, func() {
 		x := InitMySQLTestDB(t)
 
-		origXormEngine := tsdb.NewXormEngine
-		tsdb.NewXormEngine = func(d, c string) (*xorm.Engine, error) {
+		origXormEngine := sqleng.NewXormEngine
+		sqleng.NewXormEngine = func(d, c string) (*xorm.Engine, error) {
 			return x, nil
 		}
 
-		origInterpolate := tsdb.Interpolate
-		tsdb.Interpolate = func(query *tsdb.Query, timeRange *tsdb.TimeRange, sql string) (string, error) {
+		origInterpolate := sqleng.Interpolate
+		sqleng.Interpolate = func(query *tsdb.Query, timeRange *tsdb.TimeRange, sql string) (string, error) {
 			return sql, nil
 		}
 
@@ -59,8 +61,8 @@ func TestMySQL(t *testing.T) {
 
 		Reset(func() {
 			sess.Close()
-			tsdb.NewXormEngine = origXormEngine
-			tsdb.Interpolate = origInterpolate
+			sqleng.NewXormEngine = origXormEngine
+			sqleng.Interpolate = origInterpolate
 		})
 
 		Convey("Given a table with different native data types", func() {
@@ -303,11 +305,11 @@ func TestMySQL(t *testing.T) {
 			})
 
 			Convey("When doing a metric query using timeGroup and $__interval", func() {
-				mockInterpolate := tsdb.Interpolate
-				tsdb.Interpolate = origInterpolate
+				mockInterpolate := sqleng.Interpolate
+				sqleng.Interpolate = origInterpolate
 
 				Reset(func() {
-					tsdb.Interpolate = mockInterpolate
+					sqleng.Interpolate = mockInterpolate
 				})
 
 				Convey("Should replace $__interval", func() {
@@ -754,7 +756,7 @@ func TestMySQL(t *testing.T) {
 		})
 
 		Convey("When doing a query with timeFrom,timeTo,unixEpochFrom,unixEpochTo macros", func() {
-			tsdb.Interpolate = origInterpolate
+			sqleng.Interpolate = origInterpolate
 			query := &tsdb.TsdbQuery{
 				TimeRange: tsdb.NewFakeTimeRange("5m", "now", fromStart),
 				Queries: []*tsdb.Query{

pkg/tsdb/postgres/macros.go

@@ -8,21 +8,22 @@ import (
 
 	"github.com/grafana/grafana/pkg/components/gtime"
 	"github.com/grafana/grafana/pkg/tsdb"
+	"github.com/grafana/grafana/pkg/tsdb/sqleng"
 )
 
 const rsIdentifier = `([_a-zA-Z0-9]+)`
 const sExpr = `\$` + rsIdentifier + `\(([^\)]*)\)`
 
 type postgresMacroEngine struct {
-	*tsdb.SqlMacroEngineBase
+	*sqleng.SqlMacroEngineBase
 	timeRange   *tsdb.TimeRange
 	query       *tsdb.Query
 	timescaledb bool
 }
 
-func newPostgresMacroEngine(timescaledb bool) tsdb.SqlMacroEngine {
+func newPostgresMacroEngine(timescaledb bool) sqleng.SqlMacroEngine {
 	return &postgresMacroEngine{
-		SqlMacroEngineBase: tsdb.NewSqlMacroEngineBase(),
+		SqlMacroEngineBase: sqleng.NewSqlMacroEngineBase(),
 		timescaledb:        timescaledb,
 	}
 }
@@ -101,7 +102,7 @@ func (m *postgresMacroEngine) evaluateMacro(name string, args []string) (string,
 			return "", fmt.Errorf("error parsing interval %v", args[1])
 		}
 		if len(args) == 3 {
-			err := tsdb.SetupFillmode(m.query, interval, args[2])
+			err := sqleng.SetupFillmode(m.query, interval, args[2])
 			if err != nil {
 				return "", err
 			}
@@ -145,7 +146,7 @@ func (m *postgresMacroEngine) evaluateMacro(name string, args []string) (string,
 			return "", fmt.Errorf("error parsing interval %v", args[1])
 		}
 		if len(args) == 3 {
-			err := tsdb.SetupFillmode(m.query, interval, args[2])
+			err := sqleng.SetupFillmode(m.query, interval, args[2])
 			if err != nil {
 				return "", err
 			}

pkg/tsdb/postgres/postgres.go

@@ -2,14 +2,16 @@ package postgres
 
 import (
 	"database/sql"
-	"github.com/grafana/grafana/pkg/setting"
 	"net/url"
 	"strconv"
 
+	"github.com/grafana/grafana/pkg/setting"
+
 	"github.com/go-xorm/core"
 	"github.com/grafana/grafana/pkg/infra/log"
 	"github.com/grafana/grafana/pkg/models"
 	"github.com/grafana/grafana/pkg/tsdb"
+	"github.com/grafana/grafana/pkg/tsdb/sqleng"
 )
 
 func init() {
@@ -24,7 +26,7 @@ func newPostgresQueryEndpoint(datasource *models.DataSource) (tsdb.TsdbQueryEndp
 		logger.Debug("getEngine", "connection", cnnstr)
 	}
 
-	config := tsdb.SqlQueryEndpointConfiguration{
+	config := sqleng.SqlQueryEndpointConfiguration{
 		DriverName:        "postgres",
 		ConnectionString:  cnnstr,
 		Datasource:        datasource,
@@ -37,7 +39,7 @@ func newPostgresQueryEndpoint(datasource *models.DataSource) (tsdb.TsdbQueryEndp
 
 	timescaledb := datasource.JsonData.Get("timescaledb").MustBool(false)
 
-	return tsdb.NewSqlQueryEndpoint(&config, &rowTransformer, newPostgresMacroEngine(timescaledb), logger)
+	return sqleng.NewSqlQueryEndpoint(&config, &rowTransformer, newPostgresMacroEngine(timescaledb), logger)
 }
 
 func generateConnectionString(datasource *models.DataSource) string {

pkg/tsdb/postgres/postgres_test.go

@@ -15,6 +15,8 @@ import (
 	"github.com/grafana/grafana/pkg/services/sqlstore"
 	"github.com/grafana/grafana/pkg/services/sqlstore/sqlutil"
 	"github.com/grafana/grafana/pkg/tsdb"
+	"github.com/grafana/grafana/pkg/tsdb/sqleng"
+
 	_ "github.com/lib/pq"
 	. "github.com/smartystreets/goconvey/convey"
 )
@@ -39,13 +41,13 @@ func TestPostgres(t *testing.T) {
 	Convey("PostgreSQL", t, func() {
 		x := InitPostgresTestDB(t)
 
-		origXormEngine := tsdb.NewXormEngine
-		tsdb.NewXormEngine = func(d, c string) (*xorm.Engine, error) {
+		origXormEngine := sqleng.NewXormEngine
+		sqleng.NewXormEngine = func(d, c string) (*xorm.Engine, error) {
 			return x, nil
 		}
 
-		origInterpolate := tsdb.Interpolate
-		tsdb.Interpolate = func(query *tsdb.Query, timeRange *tsdb.TimeRange, sql string) (string, error) {
+		origInterpolate := sqleng.Interpolate
+		sqleng.Interpolate = func(query *tsdb.Query, timeRange *tsdb.TimeRange, sql string) (string, error) {
 			return sql, nil
 		}
 
@@ -60,8 +62,8 @@ func TestPostgres(t *testing.T) {
 
 		Reset(func() {
 			sess.Close()
-			tsdb.NewXormEngine = origXormEngine
-			tsdb.Interpolate = origInterpolate
+			sqleng.NewXormEngine = origXormEngine
+			sqleng.Interpolate = origInterpolate
 		})
 
 		Convey("Given a table with different native data types", func() {
@@ -230,11 +232,11 @@ func TestPostgres(t *testing.T) {
 			})
 
 			Convey("When doing a metric query using timeGroup and $__interval", func() {
-				mockInterpolate := tsdb.Interpolate
-				tsdb.Interpolate = origInterpolate
+				mockInterpolate := sqleng.Interpolate
+				sqleng.Interpolate = origInterpolate
 
 				Reset(func() {
-					tsdb.Interpolate = mockInterpolate
+					sqleng.Interpolate = mockInterpolate
 				})
 
 				Convey("Should replace $__interval", func() {
@@ -686,7 +688,7 @@ func TestPostgres(t *testing.T) {
 			})
 
 			Convey("When doing a query with timeFrom,timeTo,unixEpochFrom,unixEpochTo macros", func() {
-				tsdb.Interpolate = origInterpolate
+				sqleng.Interpolate = origInterpolate
 				query := &tsdb.TsdbQuery{
 					TimeRange: tsdb.NewFakeTimeRange("5m", "now", fromStart),
 					Queries: []*tsdb.Query{

pkg/tsdb/sqleng/sql_engine.go

@@ -1,4 +1,4 @@
-package tsdb
+package sqleng
 
 import (
 	"container/list"
@@ -13,6 +13,7 @@ import (
 	"time"
 
 	"github.com/grafana/grafana/pkg/infra/log"
+	"github.com/grafana/grafana/pkg/tsdb"
 
 	"github.com/grafana/grafana/pkg/components/null"
 
@@ -25,12 +26,12 @@ import (
 // SqlMacroEngine interpolates macros into sql. It takes in the Query to have access to query context and
 // timeRange to be able to generate queries that use from and to.
 type SqlMacroEngine interface {
-	Interpolate(query *Query, timeRange *TimeRange, sql string) (string, error)
+	Interpolate(query *tsdb.Query, timeRange *tsdb.TimeRange, sql string) (string, error)
 }
 
 // SqlTableRowTransformer transforms a query result row to RowValues with proper types.
 type SqlTableRowTransformer interface {
-	Transform(columnTypes []*sql.ColumnType, rows *core.Rows) (RowValues, error)
+	Transform(columnTypes []*sql.ColumnType, rows *core.Rows) (tsdb.RowValues, error)
 }
 
 type engineCacheType struct {
@@ -44,7 +45,7 @@ var engineCache = engineCacheType{
 	versions: make(map[int64]int),
 }
 
-var sqlIntervalCalculator = NewIntervalCalculator(nil)
+var sqlIntervalCalculator = tsdb.NewIntervalCalculator(nil)
 
 var NewXormEngine = func(driverName string, connectionString string) (*xorm.Engine, error) {
 	return xorm.NewEngine(driverName, connectionString)
@@ -67,7 +68,7 @@ type SqlQueryEndpointConfiguration struct {
 	MetricColumnTypes []string
 }
 
-var NewSqlQueryEndpoint = func(config *SqlQueryEndpointConfiguration, rowTransformer SqlTableRowTransformer, macroEngine SqlMacroEngine, log log.Logger) (TsdbQueryEndpoint, error) {
+var NewSqlQueryEndpoint = func(config *SqlQueryEndpointConfiguration, rowTransformer SqlTableRowTransformer, macroEngine SqlMacroEngine, log log.Logger) (tsdb.TsdbQueryEndpoint, error) {
 	queryEndpoint := sqlQueryEndpoint{
 		rowTransformer:  rowTransformer,
 		macroEngine:     macroEngine,
@@ -115,9 +116,9 @@ var NewSqlQueryEndpoint = func(config *SqlQueryEndpointConfiguration, rowTransfo
 const rowLimit = 1000000
 
 // Query is the main function for the SqlQueryEndpoint
-func (e *sqlQueryEndpoint) Query(ctx context.Context, dsInfo *models.DataSource, tsdbQuery *TsdbQuery) (*Response, error) {
-	result := &Response{
-		Results: make(map[string]*QueryResult),
+func (e *sqlQueryEndpoint) Query(ctx context.Context, dsInfo *models.DataSource, tsdbQuery *tsdb.TsdbQuery) (*tsdb.Response, error) {
+	result := &tsdb.Response{
+		Results: make(map[string]*tsdb.QueryResult),
 	}
 
 	var wg sync.WaitGroup
@@ -128,7 +129,7 @@ func (e *sqlQueryEndpoint) Query(ctx context.Context, dsInfo *models.DataSource,
 			continue
 		}
 
-		queryResult := &QueryResult{Meta: simplejson.New(), RefId: query.RefId}
+		queryResult := &tsdb.QueryResult{Meta: simplejson.New(), RefId: query.RefId}
 		result.Results[query.RefId] = queryResult
 
 		// global substitutions
@@ -149,7 +150,7 @@ func (e *sqlQueryEndpoint) Query(ctx context.Context, dsInfo *models.DataSource,
 
 		wg.Add(1)
 
-		go func(rawSQL string, query *Query, queryResult *QueryResult) {
+		go func(rawSQL string, query *tsdb.Query, queryResult *tsdb.QueryResult) {
 			defer wg.Done()
 			session := e.engine.NewSession()
 			defer session.Close()
@@ -187,8 +188,8 @@ func (e *sqlQueryEndpoint) Query(ctx context.Context, dsInfo *models.DataSource,
 }
 
 // global macros/substitutions for all sql datasources
-var Interpolate = func(query *Query, timeRange *TimeRange, sql string) (string, error) {
-	minInterval, err := GetIntervalFrom(query.DataSource, query.Model, time.Second*60)
+var Interpolate = func(query *tsdb.Query, timeRange *tsdb.TimeRange, sql string) (string, error) {
+	minInterval, err := tsdb.GetIntervalFrom(query.DataSource, query.Model, time.Second*60)
 	if err != nil {
 		return sql, nil
 	}
@@ -202,7 +203,7 @@ var Interpolate = func(query *Query, timeRange *TimeRange, sql string) (string,
 	return sql, nil
 }
 
-func (e *sqlQueryEndpoint) transformToTable(query *Query, rows *core.Rows, result *QueryResult, tsdbQuery *TsdbQuery) error {
+func (e *sqlQueryEndpoint) transformToTable(query *tsdb.Query, rows *core.Rows, result *tsdb.QueryResult, tsdbQuery *tsdb.TsdbQuery) error {
 	columnNames, err := rows.Columns()
 	columnCount := len(columnNames)
 
@@ -213,9 +214,9 @@ func (e *sqlQueryEndpoint) transformToTable(query *Query, rows *core.Rows, resul
 	rowCount := 0
 	timeIndex := -1
 
-	table := &Table{
-		Columns: make([]TableColumn, columnCount),
-		Rows:    make([]RowValues, 0),
+	table := &tsdb.Table{
+		Columns: make([]tsdb.TableColumn, columnCount),
+		Rows:    make([]tsdb.RowValues, 0),
 	}
 
 	for i, name := range columnNames {
@@ -256,8 +257,8 @@ func (e *sqlQueryEndpoint) transformToTable(query *Query, rows *core.Rows, resul
 	return nil
 }
 
-func (e *sqlQueryEndpoint) transformToTimeSeries(query *Query, rows *core.Rows, result *QueryResult, tsdbQuery *TsdbQuery) error {
-	pointsBySeries := make(map[string]*TimeSeries)
+func (e *sqlQueryEndpoint) transformToTimeSeries(query *tsdb.Query, rows *core.Rows, result *tsdb.QueryResult, tsdbQuery *tsdb.TsdbQuery) error {
+	pointsBySeries := make(map[string]*tsdb.TimeSeries)
 	seriesByQueryOrder := list.New()
 
 	columnNames, err := rows.Columns()
@@ -385,7 +386,7 @@ func (e *sqlQueryEndpoint) transformToTimeSeries(query *Query, rows *core.Rows,
 
 			series, exist := pointsBySeries[metric]
 			if !exist {
-				series = &TimeSeries{Name: metric}
+				series = &tsdb.TimeSeries{Name: metric}
 				pointsBySeries[metric] = series
 				seriesByQueryOrder.PushBack(metric)
 			}
@@ -410,12 +411,12 @@ func (e *sqlQueryEndpoint) transformToTimeSeries(query *Query, rows *core.Rows,
 				intervalStart = math.Floor(intervalStart/fillInterval) * fillInterval
 
 				for i := intervalStart; i < timestamp; i += fillInterval {
-					series.Points = append(series.Points, TimePoint{fillValue, null.FloatFrom(i)})
+					series.Points = append(series.Points, tsdb.TimePoint{fillValue, null.FloatFrom(i)})
 					rowCount++
 				}
 			}
 
-			series.Points = append(series.Points, TimePoint{value, null.FloatFrom(timestamp)})
+			series.Points = append(series.Points, tsdb.TimePoint{value, null.FloatFrom(timestamp)})
 
 			e.log.Debug("Rows", "metric", metric, "time", timestamp, "value", value)
 		}
@@ -442,7 +443,7 @@ func (e *sqlQueryEndpoint) transformToTimeSeries(query *Query, rows *core.Rows,
 			// align interval start
 			intervalStart = math.Floor(intervalStart/fillInterval) * fillInterval
 			for i := intervalStart + fillInterval; i < intervalEnd; i += fillInterval {
-				series.Points = append(series.Points, TimePoint{fillValue, null.FloatFrom(i)})
+				series.Points = append(series.Points, tsdb.TimePoint{fillValue, null.FloatFrom(i)})
 				rowCount++
 			}
 		}
@@ -454,7 +455,7 @@ func (e *sqlQueryEndpoint) transformToTimeSeries(query *Query, rows *core.Rows,
 
 // ConvertSqlTimeColumnToEpochMs converts column named time to unix timestamp in milliseconds
 // to make native datetime types and epoch dates work in annotation and table queries.
-func ConvertSqlTimeColumnToEpochMs(values RowValues, timeIndex int) {
+func ConvertSqlTimeColumnToEpochMs(values tsdb.RowValues, timeIndex int) {
 	if timeIndex >= 0 {
 		switch value := values[timeIndex].(type) {
 		case time.Time:
@@ -464,40 +465,40 @@ func ConvertSqlTimeColumnToEpochMs(values RowValues, timeIndex int) {
 				values[timeIndex] = float64((*value).UnixNano()) / float64(time.Millisecond)
 			}
 		case int64:
-			values[timeIndex] = int64(EpochPrecisionToMs(float64(value)))
+			values[timeIndex] = int64(tsdb.EpochPrecisionToMs(float64(value)))
 		case *int64:
 			if value != nil {
-				values[timeIndex] = int64(EpochPrecisionToMs(float64(*value)))
+				values[timeIndex] = int64(tsdb.EpochPrecisionToMs(float64(*value)))
 			}
 		case uint64:
-			values[timeIndex] = int64(EpochPrecisionToMs(float64(value)))
+			values[timeIndex] = int64(tsdb.EpochPrecisionToMs(float64(value)))
 		case *uint64:
 			if value != nil {
-				values[timeIndex] = int64(EpochPrecisionToMs(float64(*value)))
+				values[timeIndex] = int64(tsdb.EpochPrecisionToMs(float64(*value)))
 			}
 		case int32:
-			values[timeIndex] = int64(EpochPrecisionToMs(float64(value)))
+			values[timeIndex] = int64(tsdb.EpochPrecisionToMs(float64(value)))
 		case *int32:
 			if value != nil {
-				values[timeIndex] = int64(EpochPrecisionToMs(float64(*value)))
+				values[timeIndex] = int64(tsdb.EpochPrecisionToMs(float64(*value)))
 			}
 		case uint32:
-			values[timeIndex] = int64(EpochPrecisionToMs(float64(value)))
+			values[timeIndex] = int64(tsdb.EpochPrecisionToMs(float64(value)))
 		case *uint32:
 			if value != nil {
-				values[timeIndex] = int64(EpochPrecisionToMs(float64(*value)))
+				values[timeIndex] = int64(tsdb.EpochPrecisionToMs(float64(*value)))
 			}
 		case float64:
-			values[timeIndex] = EpochPrecisionToMs(value)
+			values[timeIndex] = tsdb.EpochPrecisionToMs(value)
 		case *float64:
 			if value != nil {
-				values[timeIndex] = EpochPrecisionToMs(*value)
+				values[timeIndex] = tsdb.EpochPrecisionToMs(*value)
 			}
 		case float32:
-			values[timeIndex] = EpochPrecisionToMs(float64(value))
+			values[timeIndex] = tsdb.EpochPrecisionToMs(float64(value))
 		case *float32:
 			if value != nil {
-				values[timeIndex] = EpochPrecisionToMs(float64(*value))
+				values[timeIndex] = tsdb.EpochPrecisionToMs(float64(*value))
 			}
 		}
 	}
@@ -609,7 +610,7 @@ func ConvertSqlValueColumnToFloat(columnName string, columnValue interface{}) (n
 	return value, nil
 }
 
-func SetupFillmode(query *Query, interval time.Duration, fillmode string) error {
+func SetupFillmode(query *tsdb.Query, interval time.Duration, fillmode string) error {
 	query.Model.Set("fill", true)
 	query.Model.Set("fillInterval", interval.Seconds())
 	switch fillmode {

pkg/tsdb/sqleng/sql_engine_test.go

@@ -1,4 +1,4 @@
-package tsdb
+package sqleng
 
 import (
 	"fmt"
@@ -8,6 +8,7 @@ import (
 	"github.com/grafana/grafana/pkg/components/null"
 	"github.com/grafana/grafana/pkg/components/simplejson"
 	"github.com/grafana/grafana/pkg/models"
+	"github.com/grafana/grafana/pkg/tsdb"
 
 	. "github.com/smartystreets/goconvey/convey"
 )
@@ -20,8 +21,8 @@ func TestSqlEngine(t *testing.T) {
 		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 := NewFakeTimeRange("5m", "now", to)
-			query := &Query{DataSource: &models.DataSource{}, Model: simplejson.New()}
+			timeRange := tsdb.NewFakeTimeRange("5m", "now", to)
+			query := &tsdb.Query{DataSource: &models.DataSource{}, Model: simplejson.New()}
 
 			Convey("interpolate $__interval", func() {
 				sql, err := Interpolate(query, timeRange, "select $__interval ")