Postgres Data Source (#9475)

* add postgresql datasource

* add rest of files for postgres datasource

* fix timeseries query, remove unused code

* consistent naming, refactoring

* s/mysql/postgres/

* s/mysql/postgres/

* couple more tests

* tests for more datatypes

* fix macros for postgres

* add __timeSec macro

* add frontend for postgres datasource

* adjust documentation

* fix formatting

* add proper plugin description

* merge editor changes from mysql

* port changes from mysql datasource

* set proper defaultQuery for postgres

* add time_sec to timeseries query
accept int for value for timeseries query

* revert allowing time_sec and handle int or float values as unix
timestamp for "time" column

* fix tslint error

* handle decimal values in timeseries query

* allow setting sslmode for postgres datasource

* use type switch for handling data types

* fix value for timeseries query

* refactor timeseries queries to make them more flexible

* remove debug statement from inner loop in type conversion

* use plain for loop in getTypedRowData

* fix timeseries queries

* adjust postgres datasource to tsdb refactoring

* adjust postgres datasource to frontend changes

* update lib/pq to latest version

* move type conversion to getTypedRowData

* handle address types cidr, inet and macaddr

* adjust response parser and docs for annotations

* convert unknown types to string

* add documentation for postgres datasource

* add another example query with metric column

* set more helpful default query

* update help text in query editor

* handle NULL in value column of timeseries query

* add __timeGroup macro

* add test for __timeGroup macro

* document __timeGroup and set proper default query for annotations

* fix typos in docs

* add postgres to list of datasources

* add postgres to builtInPlugins

* mysql: refactoring as prep for merging postgres

Refactors out the initialization of the xorm engine and the query logic
for an sql data source.

* mysql: rename refactoring + test update

* postgres:refactor to use SqlEngine(same as mysql)

Refactored to use a common base class with the MySql data source.

Other changes from the original PR:
- Changed time column to be time_sec to allow other time units in the
future and to be the same as MySQL
- Changed integration test to test the main Query method rather than
the private transformToTable method
- Changed the __timeSec macro name to __timeEpoch
- Renamed PostgresExecutor to PostgresQueryEndpoint

Fixes #9209 (the original PR)

* postgres: encrypt password on config page

With some other cosmetic changes to the config page:
- placeholder texts
- reset button for the password after it has been encrypted.
- default value for the sslmode field.

* postgres: change back col name to time from time_sec

* postgres mysql: remove annotation title

Title has been removed from annotations

* postgres: fix images for docs page

* postgres mysql: fix specs

pkg/tsdb/sql_engine.go

@@ -0,0 +1,134 @@
+package tsdb
+
+import (
+	"context"
+	"sync"
+
+	"github.com/go-xorm/core"
+	"github.com/go-xorm/xorm"
+	"github.com/grafana/grafana/pkg/components/simplejson"
+	"github.com/grafana/grafana/pkg/models"
+)
+
+// SqlEngine is a wrapper class around xorm for relational database data sources.
+type SqlEngine interface {
+	InitEngine(driverName string, dsInfo *models.DataSource, cnnstr string) error
+	Query(
+		ctx context.Context,
+		ds *models.DataSource,
+		query *TsdbQuery,
+		transformToTimeSeries func(query *Query, rows *core.Rows, result *QueryResult) error,
+		transformToTable func(query *Query, rows *core.Rows, result *QueryResult) error,
+	) (*Response, error)
+}
+
+// SqlMacroEngine interpolates macros into sql. It takes in the timeRange to be able to
+// generate queries that use from and to.
+type SqlMacroEngine interface {
+	Interpolate(timeRange *TimeRange, sql string) (string, error)
+}
+
+type DefaultSqlEngine struct {
+	MacroEngine SqlMacroEngine
+	XormEngine  *xorm.Engine
+}
+
+type engineCacheType struct {
+	cache    map[int64]*xorm.Engine
+	versions map[int64]int
+	sync.Mutex
+}
+
+var engineCache = engineCacheType{
+	cache:    make(map[int64]*xorm.Engine),
+	versions: make(map[int64]int),
+}
+
+// InitEngine creates the db connection and inits the xorm engine or loads it from the engine cache
+func (e *DefaultSqlEngine) InitEngine(driverName string, dsInfo *models.DataSource, cnnstr string) error {
+	engineCache.Lock()
+	defer engineCache.Unlock()
+
+	if engine, present := engineCache.cache[dsInfo.Id]; present {
+		if version, _ := engineCache.versions[dsInfo.Id]; version == dsInfo.Version {
+			e.XormEngine = engine
+			return nil
+		}
+	}
+
+	engine, err := xorm.NewEngine(driverName, cnnstr)
+	engine.SetMaxOpenConns(10)
+	engine.SetMaxIdleConns(10)
+	if err != nil {
+		return err
+	}
+
+	engineCache.cache[dsInfo.Id] = engine
+	e.XormEngine = engine
+
+	return nil
+}
+
+// Query is a default implementation of the Query method for an SQL data source.
+// The caller of this function must implement transformToTimeSeries and transformToTable and
+// pass them in as parameters.
+func (e *DefaultSqlEngine) Query(
+	ctx context.Context,
+	dsInfo *models.DataSource,
+	tsdbQuery *TsdbQuery,
+	transformToTimeSeries func(query *Query, rows *core.Rows, result *QueryResult) error,
+	transformToTable func(query *Query, rows *core.Rows, result *QueryResult) error,
+) (*Response, error) {
+	result := &Response{
+		Results: make(map[string]*QueryResult),
+	}
+
+	session := e.XormEngine.NewSession()
+	defer session.Close()
+	db := session.DB()
+
+	for _, query := range tsdbQuery.Queries {
+		rawSql := query.Model.Get("rawSql").MustString()
+		if rawSql == "" {
+			continue
+		}
+
+		queryResult := &QueryResult{Meta: simplejson.New(), RefId: query.RefId}
+		result.Results[query.RefId] = queryResult
+
+		rawSql, err := e.MacroEngine.Interpolate(tsdbQuery.TimeRange, rawSql)
+		if err != nil {
+			queryResult.Error = err
+			continue
+		}
+
+		queryResult.Meta.Set("sql", rawSql)
+
+		rows, err := db.Query(rawSql)
+		if err != nil {
+			queryResult.Error = err
+			continue
+		}
+
+		defer rows.Close()
+
+		format := query.Model.Get("format").MustString("time_series")
+
+		switch format {
+		case "time_series":
+			err := transformToTimeSeries(query, rows, queryResult)
+			if err != nil {
+				queryResult.Error = err
+				continue
+			}
+		case "table":
+			err := transformToTable(query, rows, queryResult)
+			if err != nil {
+				queryResult.Error = err
+				continue
+			}
+		}
+	}
+
+	return result, nil
+}