tech(influxdb): refactor query builder

trying to reduce the amounts of moving parts for influxdb

Author: bergquist

pkg/tsdb/influxdb/influxdb.go

@@ -18,15 +18,13 @@ import (
 type InfluxDBExecutor struct {
 	*tsdb.DataSourceInfo
 	QueryParser    *InfluxdbQueryParser
-	QueryBuilder   *QueryBuilder
 	ResponseParser *ResponseParser
 }
 
 func NewInfluxDBExecutor(dsInfo *tsdb.DataSourceInfo) tsdb.Executor {
 	return &InfluxDBExecutor{
 		DataSourceInfo: dsInfo,
 		QueryParser:    &InfluxdbQueryParser{},
-		QueryBuilder:   &QueryBuilder{},
 		ResponseParser: &ResponseParser{},
 	}
 }
@@ -51,7 +49,7 @@ func (e *InfluxDBExecutor) Execute(ctx context.Context, queries tsdb.QuerySlice,
 		return result.WithError(err)
 	}
 
-	rawQuery, err := e.QueryBuilder.Build(query, context)
+	rawQuery, err := query.Build(context)
 	if err != nil {
 		return result.WithError(err)
 	}

pkg/tsdb/influxdb/query_builder.go renamed to pkg/tsdb/influxdb/query.go

@@ -14,28 +14,26 @@ var (
 	regexpOperatorPattern *regexp.Regexp = regexp.MustCompile(`^\/.*\/$`)
 )
 
-type QueryBuilder struct{}
-
-func (qb *QueryBuilder) Build(query *Query, queryContext *tsdb.QueryContext) (string, error) {
+func (query *Query) Build(queryContext *tsdb.QueryContext) (string, error) {
 	if query.UseRawQuery && query.RawQuery != "" {
 		q := query.RawQuery
 
-		q = strings.Replace(q, "$timeFilter", qb.renderTimeFilter(query, queryContext), 1)
+		q = strings.Replace(q, "$timeFilter", query.renderTimeFilter(queryContext), 1)
 		q = strings.Replace(q, "$interval", tsdb.CalculateInterval(queryContext.TimeRange), 1)
 
 		return q, nil
 	}
 
-	res := qb.renderSelectors(query, queryContext)
-	res += qb.renderMeasurement(query)
-	res += qb.renderWhereClause(query)
-	res += qb.renderTimeFilter(query, queryContext)
-	res += qb.renderGroupBy(query, queryContext)
+	res := query.renderSelectors(queryContext)
+	res += query.renderMeasurement()
+	res += query.renderWhereClause()
+	res += query.renderTimeFilter(queryContext)
+	res += query.renderGroupBy(queryContext)
 
 	return res, nil
 }
 
-func (qb *QueryBuilder) renderTags(query *Query) []string {
+func (query *Query) renderTags() []string {
 	var res []string
 	for i, tag := range query.Tags {
 		str := ""
@@ -76,7 +74,7 @@ func (qb *QueryBuilder) renderTags(query *Query) []string {
 	return res
 }
 
-func (qb *QueryBuilder) renderTimeFilter(query *Query, queryContext *tsdb.QueryContext) string {
+func (query *Query) renderTimeFilter(queryContext *tsdb.QueryContext) string {
 	from := "now() - " + queryContext.TimeRange.From
 	to := ""
 
@@ -87,7 +85,7 @@ func (qb *QueryBuilder) renderTimeFilter(query *Query, queryContext *tsdb.QueryC
 	return fmt.Sprintf("time > %s%s", from, to)
 }
 
-func (qb *QueryBuilder) renderSelectors(query *Query, queryContext *tsdb.QueryContext) string {
+func (query *Query) renderSelectors(queryContext *tsdb.QueryContext) string {
 	res := "SELECT "
 
 	var selectors []string
@@ -103,7 +101,7 @@ func (qb *QueryBuilder) renderSelectors(query *Query, queryContext *tsdb.QueryCo
 	return res + strings.Join(selectors, ", ")
 }
 
-func (qb *QueryBuilder) renderMeasurement(query *Query) string {
+func (query *Query) renderMeasurement() string {
 	policy := ""
 	if query.Policy == "" || query.Policy == "default" {
 		policy = ""
@@ -113,9 +111,9 @@ func (qb *QueryBuilder) renderMeasurement(query *Query) string {
 	return fmt.Sprintf(` FROM %s"%s"`, policy, query.Measurement)
 }
 
-func (qb *QueryBuilder) renderWhereClause(query *Query) string {
+func (query *Query) renderWhereClause() string {
 	res := " WHERE "
-	conditions := qb.renderTags(query)
+	conditions := query.renderTags()
 	res += strings.Join(conditions, " ")
 	if len(conditions) > 0 {
 		res += " AND "
@@ -124,7 +122,7 @@ func (qb *QueryBuilder) renderWhereClause(query *Query) string {
 	return res
 }
 
-func (qb *QueryBuilder) renderGroupBy(query *Query, queryContext *tsdb.QueryContext) string {
+func (query *Query) renderGroupBy(queryContext *tsdb.QueryContext) string {
 	groupBy := ""
 	for i, group := range query.GroupBy {
 		if i == 0 {

pkg/tsdb/influxdb/query_builder_test.go renamed to pkg/tsdb/influxdb/query_test.go

@@ -12,7 +12,6 @@ import (
 func TestInfluxdbQueryBuilder(t *testing.T) {
 
 	Convey("Influxdb query builder", t, func() {
-		builder := QueryBuilder{}
 
 		qp1, _ := NewQueryPart("field", []string{"value"})
 		qp2, _ := NewQueryPart("mean", []string{})
@@ -37,7 +36,7 @@ func TestInfluxdbQueryBuilder(t *testing.T) {
 				Interval:    "10s",
 			}
 
-			rawQuery, err := builder.Build(query, queryContext)
+			rawQuery, err := query.Build(queryContext)
 			So(err, ShouldBeNil)
 			So(rawQuery, ShouldEqual, `SELECT mean("value") FROM "policy"."cpu" WHERE time > now() - 5m GROUP BY time(10s) fill(null)`)
 		})
@@ -51,23 +50,22 @@ func TestInfluxdbQueryBuilder(t *testing.T) {
 				Interval:    "5s",
 			}
 
-			rawQuery, err := builder.Build(query, queryContext)
+			rawQuery, err := query.Build(queryContext)
 			So(err, ShouldBeNil)
 			So(rawQuery, ShouldEqual, `SELECT mean("value") FROM "cpu" WHERE "hostname" = 'server1' OR "hostname" = 'server2' AND time > now() - 5m GROUP BY time(5s), "datacenter" fill(null)`)
 		})
 
 		Convey("can render time range", func() {
 			query := Query{}
-			builder := &QueryBuilder{}
 			Convey("render from: 2h to now-1h", func() {
 				query := Query{}
 				queryContext := &tsdb.QueryContext{TimeRange: tsdb.NewTimeRange("2h", "now-1h")}
-				So(builder.renderTimeFilter(&query, queryContext), ShouldEqual, "time > now() - 2h and time < now() - 1h")
+				So(query.renderTimeFilter(queryContext), ShouldEqual, "time > now() - 2h and time < now() - 1h")
 			})
 
 			Convey("render from: 10m", func() {
 				queryContext := &tsdb.QueryContext{TimeRange: tsdb.NewTimeRange("10m", "now")}
-				So(builder.renderTimeFilter(&query, queryContext), ShouldEqual, "time > now() - 10m")
+				So(query.renderTimeFilter(queryContext), ShouldEqual, "time > now() - 10m")
 			})
 		})
 
@@ -82,45 +80,45 @@ func TestInfluxdbQueryBuilder(t *testing.T) {
 				UseRawQuery: true,
 			}
 
-			rawQuery, err := builder.Build(query, queryContext)
+			rawQuery, err := query.Build(queryContext)
 			So(err, ShouldBeNil)
 			So(rawQuery, ShouldEqual, `Raw query`)
 		})
 
 		Convey("can render normal tags without operator", func() {
 			query := &Query{Tags: []*Tag{&Tag{Operator: "", Value: `value`, Key: "key"}}}
 
-			So(strings.Join(builder.renderTags(query), ""), ShouldEqual, `"key" = 'value'`)
+			So(strings.Join(query.renderTags(), ""), ShouldEqual, `"key" = 'value'`)
 		})
 
 		Convey("can render regex tags without operator", func() {
 			query := &Query{Tags: []*Tag{&Tag{Operator: "", Value: `/value/`, Key: "key"}}}
 
-			So(strings.Join(builder.renderTags(query), ""), ShouldEqual, `"key" =~ /value/`)
+			So(strings.Join(query.renderTags(), ""), ShouldEqual, `"key" =~ /value/`)
 		})
 
 		Convey("can render regex tags", func() {
 			query := &Query{Tags: []*Tag{&Tag{Operator: "=~", Value: `/value/`, Key: "key"}}}
 
-			So(strings.Join(builder.renderTags(query), ""), ShouldEqual, `"key" =~ /value/`)
+			So(strings.Join(query.renderTags(), ""), ShouldEqual, `"key" =~ /value/`)
 		})
 
 		Convey("can render number tags", func() {
 			query := &Query{Tags: []*Tag{&Tag{Operator: "=", Value: "10001", Key: "key"}}}
 
-			So(strings.Join(builder.renderTags(query), ""), ShouldEqual, `"key" = 10001`)
+			So(strings.Join(query.renderTags(), ""), ShouldEqual, `"key" = 10001`)
 		})
 
 		Convey("can render number tags with decimals", func() {
 			query := &Query{Tags: []*Tag{&Tag{Operator: "=", Value: "10001.1", Key: "key"}}}
 
-			So(strings.Join(builder.renderTags(query), ""), ShouldEqual, `"key" = 10001.1`)
+			So(strings.Join(query.renderTags(), ""), ShouldEqual, `"key" = 10001.1`)
 		})
 
 		Convey("can render string tags", func() {
 			query := &Query{Tags: []*Tag{&Tag{Operator: "=", Value: "value", Key: "key"}}}
 
-			So(strings.Join(builder.renderTags(query), ""), ShouldEqual, `"key" = 'value'`)
+			So(strings.Join(query.renderTags(), ""), ShouldEqual, `"key" = 'value'`)
 		})
 	})
 }