Skip to content

Commit bfb85f2

Browse files
gaborgabor
authored
sql: improve sqleng-api, leave sql.DB creation to the plugins (grafana#79672)
1 parent 8923cc2 commit bfb85f2

File tree

7 files changed

+72
-92
lines changed

7 files changed

+72
-92
lines changed

‎pkg/tsdb/grafana-postgresql-datasource/postgres.go‎

Lines changed: 12 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -2,11 +2,13 @@ package postgres
22

33
import (
44
"context"
5+
"database/sql"
56
"encoding/json"
67
"fmt"
78
"reflect"
89
"strconv"
910
"strings"
11+
"time"
1012

1113
"github.com/grafana/grafana-plugin-sdk-go/backend"
1214
"github.com/grafana/grafana-plugin-sdk-go/backend/datasource"
@@ -108,16 +110,23 @@ func (s *Service) newInstanceSettings(cfg *setting.Cfg) datasource.InstanceFacto
108110
}
109111

110112
config := sqleng.DataPluginConfiguration{
111-
DriverName: driverName,
112-
ConnectionString: cnnstr,
113113
DSInfo: dsInfo,
114114
MetricColumnTypes: []string{"UNKNOWN", "TEXT", "VARCHAR", "CHAR"},
115115
RowLimit: cfg.DataProxyRowLimit,
116116
}
117117

118118
queryResultTransformer := postgresQueryResultTransformer{}
119119

120-
handler, err := sqleng.NewQueryDataHandler(cfg, config, &queryResultTransformer, newPostgresMacroEngine(dsInfo.JsonData.Timescaledb),
120+
db, err := sql.Open(driverName, cnnstr)
121+
if err != nil {
122+
return nil, err
123+
}
124+
125+
db.SetMaxOpenConns(config.DSInfo.JsonData.MaxOpenConns)
126+
db.SetMaxIdleConns(config.DSInfo.JsonData.MaxIdleConns)
127+
db.SetConnMaxLifetime(time.Duration(config.DSInfo.JsonData.ConnMaxLifetime) * time.Second)
128+
129+
handler, err := sqleng.NewQueryDataHandler(cfg, db, config, &queryResultTransformer, newPostgresMacroEngine(dsInfo.JsonData.Timescaledb),
121130
logger)
122131
if err != nil {
123132
logger.Error("Failed connecting to Postgres", "err", err)

‎pkg/tsdb/grafana-postgresql-datasource/postgres_test.go‎

Lines changed: 12 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -184,17 +184,10 @@ func TestIntegrationPostgres(t *testing.T) {
184184
t.Skip()
185185
}
186186

187-
x := InitPostgresTestDB(t)
188-
189-
origDB := sqleng.NewDB
190187
origInterpolate := sqleng.Interpolate
191188
t.Cleanup(func() {
192-
sqleng.NewDB = origDB
193189
sqleng.Interpolate = origInterpolate
194190
})
195-
sqleng.NewDB = func(d, c string) (*sql.DB, error) {
196-
return x, nil
197-
}
198191
sqleng.Interpolate = func(query backend.DataQuery, timeRange backend.TimeRange, timeInterval string, sql string) (string, error) {
199192
return sql, nil
200193
}
@@ -216,8 +209,6 @@ func TestIntegrationPostgres(t *testing.T) {
216209
}
217210

218211
config := sqleng.DataPluginConfiguration{
219-
DriverName: "postgres",
220-
ConnectionString: "",
221212
DSInfo: dsInfo,
222213
MetricColumnTypes: []string{"UNKNOWN", "TEXT", "VARCHAR", "CHAR"},
223214
RowLimit: 1000000,
@@ -226,12 +217,14 @@ func TestIntegrationPostgres(t *testing.T) {
226217
queryResultTransformer := postgresQueryResultTransformer{}
227218

228219
logger := backend.NewLoggerWith("logger", "postgres.test")
229-
exe, err := sqleng.NewQueryDataHandler(cfg, config, &queryResultTransformer, newPostgresMacroEngine(dsInfo.JsonData.Timescaledb),
220+
221+
db := InitPostgresTestDB(t, jsonData)
222+
223+
exe, err := sqleng.NewQueryDataHandler(cfg, db, config, &queryResultTransformer, newPostgresMacroEngine(dsInfo.JsonData.Timescaledb),
230224
logger)
231225

232226
require.NoError(t, err)
233227

234-
db := x
235228
fromStart := time.Date(2018, 3, 15, 13, 0, 0, 0, time.UTC).In(time.Local)
236229

237230
t.Run("Given a table with different native data types", func(t *testing.T) {
@@ -1282,16 +1275,14 @@ func TestIntegrationPostgres(t *testing.T) {
12821275
t.Run("When row limit set to 1", func(t *testing.T) {
12831276
dsInfo := sqleng.DataSourceInfo{}
12841277
config := sqleng.DataPluginConfiguration{
1285-
DriverName: "postgres",
1286-
ConnectionString: "",
12871278
DSInfo: dsInfo,
12881279
MetricColumnTypes: []string{"UNKNOWN", "TEXT", "VARCHAR", "CHAR"},
12891280
RowLimit: 1,
12901281
}
12911282

12921283
queryResultTransformer := postgresQueryResultTransformer{}
12931284

1294-
handler, err := sqleng.NewQueryDataHandler(setting.NewCfg(), config, &queryResultTransformer, newPostgresMacroEngine(false), logger)
1285+
handler, err := sqleng.NewQueryDataHandler(setting.NewCfg(), db, config, &queryResultTransformer, newPostgresMacroEngine(false), logger)
12951286
require.NoError(t, err)
12961287

12971288
t.Run("When doing a table query that returns 2 rows should limit the result to 1 row", func(t *testing.T) {
@@ -1392,11 +1383,15 @@ func TestIntegrationPostgres(t *testing.T) {
13921383
})
13931384
}
13941385

1395-
func InitPostgresTestDB(t *testing.T) *sql.DB {
1386+
func InitPostgresTestDB(t *testing.T, jsonData sqleng.JsonData) *sql.DB {
13961387
connStr := postgresTestDBConnString()
1397-
x, err := sql.Open("postgres", connStr)
1388+
db, err := sql.Open("postgres", connStr)
13981389
require.NoError(t, err, "Failed to init postgres DB")
1399-
return x
1390+
1391+
db.SetMaxOpenConns(jsonData.MaxOpenConns)
1392+
db.SetMaxIdleConns(jsonData.MaxIdleConns)
1393+
db.SetConnMaxLifetime(time.Duration(jsonData.ConnMaxLifetime) * time.Second)
1394+
return db
14001395
}
14011396

14021397
func genTimeRangeByInterval(from time.Time, duration time.Duration, interval time.Duration) []time.Time {

‎pkg/tsdb/mssql/mssql.go‎

Lines changed: 12 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -2,13 +2,15 @@ package mssql
22

33
import (
44
"context"
5+
"database/sql"
56
"encoding/json"
67
"fmt"
78
"net/url"
89
"reflect"
910
"regexp"
1011
"strconv"
1112
"strings"
13+
"time"
1214

1315
"github.com/grafana/grafana-azure-sdk-go/azcredentials"
1416
"github.com/grafana/grafana-plugin-sdk-go/backend"
@@ -125,8 +127,6 @@ func newInstanceSettings(cfg *setting.Cfg, logger log.Logger) datasource.Instanc
125127
}
126128

127129
config := sqleng.DataPluginConfiguration{
128-
DriverName: driverName,
129-
ConnectionString: cnnstr,
130130
DSInfo: dsInfo,
131131
MetricColumnTypes: []string{"VARCHAR", "CHAR", "NVARCHAR", "NCHAR"},
132132
RowLimit: cfg.DataProxyRowLimit,
@@ -136,7 +136,16 @@ func newInstanceSettings(cfg *setting.Cfg, logger log.Logger) datasource.Instanc
136136
userError: cfg.UserFacingDefaultError,
137137
}
138138

139-
return sqleng.NewQueryDataHandler(cfg, config, &queryResultTransformer, newMssqlMacroEngine(), logger)
139+
db, err := sql.Open(driverName, cnnstr)
140+
if err != nil {
141+
return nil, err
142+
}
143+
144+
db.SetMaxOpenConns(config.DSInfo.JsonData.MaxOpenConns)
145+
db.SetMaxIdleConns(config.DSInfo.JsonData.MaxIdleConns)
146+
db.SetConnMaxLifetime(time.Duration(config.DSInfo.JsonData.ConnMaxLifetime) * time.Second)
147+
148+
return sqleng.NewQueryDataHandler(cfg, db, config, &queryResultTransformer, newMssqlMacroEngine(), logger)
140149
}
141150
}
142151

‎pkg/tsdb/mssql/mssql_test.go‎

Lines changed: 12 additions & 24 deletions
Original file line numberDiff line numberDiff line change
@@ -39,32 +39,20 @@ func TestMSSQL(t *testing.T) {
3939
t.Skip()
4040
}
4141

42-
x := initMSSQLTestDB(t)
43-
origDB := sqleng.NewDB
44-
t.Cleanup(func() {
45-
sqleng.NewDB = origDB
46-
})
47-
48-
sqleng.NewDB = func(d, c string) (*sql.DB, error) {
49-
return x, nil
50-
}
51-
5242
queryResultTransformer := mssqlQueryResultTransformer{}
5343
dsInfo := sqleng.DataSourceInfo{}
5444
config := sqleng.DataPluginConfiguration{
55-
DriverName: "mssql",
56-
ConnectionString: "",
5745
DSInfo: dsInfo,
5846
MetricColumnTypes: []string{"VARCHAR", "CHAR", "NVARCHAR", "NCHAR"},
5947
RowLimit: 1000000,
6048
}
6149

6250
logger := backend.NewLoggerWith("logger", "mssql.test")
6351

64-
endpoint, err := sqleng.NewQueryDataHandler(setting.NewCfg(), config, &queryResultTransformer, newMssqlMacroEngine(), logger)
65-
require.NoError(t, err)
52+
db := initMSSQLTestDB(t, config.DSInfo.JsonData)
6653

67-
db := x
54+
endpoint, err := sqleng.NewQueryDataHandler(setting.NewCfg(), db, config, &queryResultTransformer, newMssqlMacroEngine(), logger)
55+
require.NoError(t, err)
6856

6957
fromStart := time.Date(2018, 3, 15, 13, 0, 0, 0, time.UTC).In(time.Local)
7058

@@ -811,13 +799,11 @@ func TestMSSQL(t *testing.T) {
811799
queryResultTransformer := mssqlQueryResultTransformer{}
812800
dsInfo := sqleng.DataSourceInfo{}
813801
config := sqleng.DataPluginConfiguration{
814-
DriverName: "mssql",
815-
ConnectionString: "",
816802
DSInfo: dsInfo,
817803
MetricColumnTypes: []string{"VARCHAR", "CHAR", "NVARCHAR", "NCHAR"},
818804
RowLimit: 1000000,
819805
}
820-
endpoint, err := sqleng.NewQueryDataHandler(setting.NewCfg(), config, &queryResultTransformer, newMssqlMacroEngine(), logger)
806+
endpoint, err := sqleng.NewQueryDataHandler(setting.NewCfg(), db, config, &queryResultTransformer, newMssqlMacroEngine(), logger)
821807
require.NoError(t, err)
822808
query := &backend.QueryDataRequest{
823809
Queries: []backend.DataQuery{
@@ -1216,14 +1202,12 @@ func TestMSSQL(t *testing.T) {
12161202
queryResultTransformer := mssqlQueryResultTransformer{}
12171203
dsInfo := sqleng.DataSourceInfo{}
12181204
config := sqleng.DataPluginConfiguration{
1219-
DriverName: "mssql",
1220-
ConnectionString: "",
12211205
DSInfo: dsInfo,
12221206
MetricColumnTypes: []string{"VARCHAR", "CHAR", "NVARCHAR", "NCHAR"},
12231207
RowLimit: 1,
12241208
}
12251209

1226-
handler, err := sqleng.NewQueryDataHandler(setting.NewCfg(), config, &queryResultTransformer, newMssqlMacroEngine(), logger)
1210+
handler, err := sqleng.NewQueryDataHandler(setting.NewCfg(), db, config, &queryResultTransformer, newMssqlMacroEngine(), logger)
12271211
require.NoError(t, err)
12281212

12291213
t.Run("When doing a table query that returns 2 rows should limit the result to 1 row", func(t *testing.T) {
@@ -1487,15 +1471,19 @@ func TestGenerateConnectionString(t *testing.T) {
14871471
}
14881472
}
14891473

1490-
func initMSSQLTestDB(t *testing.T) *sql.DB {
1474+
func initMSSQLTestDB(t *testing.T, jsonData sqleng.JsonData) *sql.DB {
14911475
t.Helper()
14921476

14931477
testDB := sqlutil.MSSQLTestDB()
1494-
x, err := sql.Open(testDB.DriverName, strings.Replace(testDB.ConnStr, "localhost",
1478+
db, err := sql.Open(testDB.DriverName, strings.Replace(testDB.ConnStr, "localhost",
14951479
serverIP, 1))
14961480
require.NoError(t, err)
14971481

1498-
return x
1482+
db.SetMaxOpenConns(jsonData.MaxOpenConns)
1483+
db.SetMaxIdleConns(jsonData.MaxIdleConns)
1484+
db.SetConnMaxLifetime(time.Duration(jsonData.ConnMaxLifetime) * time.Second)
1485+
1486+
return db
14991487
}
15001488

15011489
func genTimeRangeByInterval(from time.Time, duration time.Duration, interval time.Duration) []time.Time {

‎pkg/tsdb/mysql/mysql.go‎

Lines changed: 11 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -2,6 +2,7 @@ package mysql
22

33
import (
44
"context"
5+
"database/sql"
56
"encoding/json"
67
"errors"
78
"fmt"
@@ -138,8 +139,6 @@ func newInstanceSettings(cfg *setting.Cfg, logger log.Logger) datasource.Instanc
138139
}
139140

140141
config := sqleng.DataPluginConfiguration{
141-
DriverName: "mysql",
142-
ConnectionString: cnnstr,
143142
DSInfo: dsInfo,
144143
TimeColumnNames: []string{"time", "time_sec"},
145144
MetricColumnTypes: []string{"CHAR", "VARCHAR", "TINYTEXT", "TEXT", "MEDIUMTEXT", "LONGTEXT"},
@@ -150,7 +149,16 @@ func newInstanceSettings(cfg *setting.Cfg, logger log.Logger) datasource.Instanc
150149
userError: cfg.UserFacingDefaultError,
151150
}
152151

153-
return sqleng.NewQueryDataHandler(cfg, config, &rowTransformer, newMysqlMacroEngine(logger, cfg), logger)
152+
db, err := sql.Open("mysql", cnnstr)
153+
if err != nil {
154+
return nil, err
155+
}
156+
157+
db.SetMaxOpenConns(config.DSInfo.JsonData.MaxOpenConns)
158+
db.SetMaxIdleConns(config.DSInfo.JsonData.MaxIdleConns)
159+
db.SetConnMaxLifetime(time.Duration(config.DSInfo.JsonData.ConnMaxLifetime) * time.Second)
160+
161+
return sqleng.NewQueryDataHandler(cfg, db, config, &rowTransformer, newMysqlMacroEngine(logger, cfg), logger)
154162
}
155163
}
156164

‎pkg/tsdb/mysql/mysql_test.go‎

Lines changed: 12 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -37,19 +37,11 @@ func TestIntegrationMySQL(t *testing.T) {
3737
t.Skip()
3838
}
3939

40-
x := InitMySQLTestDB(t)
41-
42-
origDB := sqleng.NewDB
4340
origInterpolate := sqleng.Interpolate
4441
t.Cleanup(func() {
45-
sqleng.NewDB = origDB
4642
sqleng.Interpolate = origInterpolate
4743
})
4844

49-
sqleng.NewDB = func(d, c string) (*sql.DB, error) {
50-
return x, nil
51-
}
52-
5345
sqleng.Interpolate = func(query backend.DataQuery, timeRange backend.TimeRange, timeInterval string, sql string) (string, error) {
5446
return sql, nil
5547
}
@@ -63,8 +55,6 @@ func TestIntegrationMySQL(t *testing.T) {
6355
}
6456

6557
config := sqleng.DataPluginConfiguration{
66-
DriverName: "mysql",
67-
ConnectionString: "",
6858
DSInfo: dsInfo,
6959
TimeColumnNames: []string{"time", "time_sec"},
7060
MetricColumnTypes: []string{"CHAR", "VARCHAR", "TINYTEXT", "TEXT", "MEDIUMTEXT", "LONGTEXT"},
@@ -74,11 +64,13 @@ func TestIntegrationMySQL(t *testing.T) {
7464
rowTransformer := mysqlQueryResultTransformer{}
7565

7666
logger := backend.NewLoggerWith("logger", "mysql.test")
77-
exe, err := sqleng.NewQueryDataHandler(setting.NewCfg(), config, &rowTransformer, newMysqlMacroEngine(logger, setting.NewCfg()), logger)
67+
68+
db := InitMySQLTestDB(t, config.DSInfo.JsonData)
69+
70+
exe, err := sqleng.NewQueryDataHandler(setting.NewCfg(), db, config, &rowTransformer, newMysqlMacroEngine(logger, setting.NewCfg()), logger)
7871

7972
require.NoError(t, err)
8073

81-
db := x
8274
fromStart := time.Date(2018, 3, 15, 13, 0, 0, 0, time.UTC)
8375

8476
t.Run("Given a table with different native data types", func(t *testing.T) {
@@ -1178,8 +1170,6 @@ func TestIntegrationMySQL(t *testing.T) {
11781170
t.Run("When row limit set to 1", func(t *testing.T) {
11791171
dsInfo := sqleng.DataSourceInfo{}
11801172
config := sqleng.DataPluginConfiguration{
1181-
DriverName: "mysql",
1182-
ConnectionString: "",
11831173
DSInfo: dsInfo,
11841174
TimeColumnNames: []string{"time", "time_sec"},
11851175
MetricColumnTypes: []string{"CHAR", "VARCHAR", "TINYTEXT", "TEXT", "MEDIUMTEXT", "LONGTEXT"},
@@ -1188,7 +1178,7 @@ func TestIntegrationMySQL(t *testing.T) {
11881178

11891179
queryResultTransformer := mysqlQueryResultTransformer{}
11901180

1191-
handler, err := sqleng.NewQueryDataHandler(setting.NewCfg(), config, &queryResultTransformer, newMysqlMacroEngine(logger, setting.NewCfg()), logger)
1181+
handler, err := sqleng.NewQueryDataHandler(setting.NewCfg(), db, config, &queryResultTransformer, newMysqlMacroEngine(logger, setting.NewCfg()), logger)
11921182
require.NoError(t, err)
11931183

11941184
t.Run("When doing a table query that returns 2 rows should limit the result to 1 row", func(t *testing.T) {
@@ -1290,14 +1280,18 @@ func TestIntegrationMySQL(t *testing.T) {
12901280
})
12911281
}
12921282

1293-
func InitMySQLTestDB(t *testing.T) *sql.DB {
1283+
func InitMySQLTestDB(t *testing.T, jsonData sqleng.JsonData) *sql.DB {
12941284
connStr := mySQLTestDBConnStr()
1295-
x, err := sql.Open("mysql", connStr)
1285+
db, err := sql.Open("mysql", connStr)
12961286
if err != nil {
12971287
t.Fatalf("Failed to init mysql db %v", err)
12981288
}
12991289

1300-
return x
1290+
db.SetMaxOpenConns(jsonData.MaxOpenConns)
1291+
db.SetMaxIdleConns(jsonData.MaxIdleConns)
1292+
db.SetConnMaxLifetime(time.Duration(jsonData.ConnMaxLifetime) * time.Second)
1293+
1294+
return db
13011295
}
13021296

13031297
func genTimeRangeByInterval(from time.Time, duration time.Duration, interval time.Duration) []time.Time {

0 commit comments

Comments
 (0)