InfluxDB: use converters from SDK (#27138)

pkg/tsdb/influxdb/flux/builder.go

@@ -5,6 +5,7 @@ import (
 	"time"
 
 	"github.com/grafana/grafana-plugin-sdk-go/data"
+	"github.com/grafana/grafana-plugin-sdk-go/data/converters"
 	"github.com/influxdata/influxdb-client-go/v2/api/query"
 )
 
@@ -47,26 +48,42 @@ func isTag(schk string) bool {
 	return (schk != "result" && schk != "table" && schk[0] != '_')
 }
 
+var timeToOptionalTime = data.FieldConverter{
+	OutputFieldType: data.FieldTypeNullableTime,
+	Converter: func(v interface{}) (interface{}, error) {
+		var ptr *time.Time
+		if v == nil {
+			return ptr, nil
+		}
+		val, ok := v.(time.Time)
+		if !ok {
+			return ptr, fmt.Errorf(`expected %s input but got type %T for value "%v"`, "time.Time", v, v)
+		}
+		ptr = &val
+		return ptr, nil
+	},
+}
+
 func getConverter(t string) (*data.FieldConverter, error) {
 	switch t {
 	case stringDatatype:
-		return &anyToOptionalString, nil
+		return &converters.AnyToNullableString, nil
 	case timeDatatypeRFC:
 		return &timeToOptionalTime, nil
 	case timeDatatypeRFCNano:
 		return &timeToOptionalTime, nil
 	case durationDatatype:
-		return &int64ToOptionalInt64, nil
+		return &converters.Int64ToNullableInt64, nil
 	case doubleDatatype:
-		return &float64ToOptionalFloat64, nil
+		return &converters.Float64ToNullableFloat64, nil
 	case boolDatatype:
-		return &boolToOptionalBool, nil
+		return &converters.BoolToNullableBool, nil
 	case longDatatype:
-		return &int64ToOptionalInt64, nil
+		return &converters.Int64ToNullableInt64, nil
 	case uLongDatatype:
-		return &uint64ToOptionalUInt64, nil
+		return &converters.Uint64ToNullableUInt64, nil
 	case base64BinaryDataType:
-		return &anyToOptionalString, nil
+		return &converters.AnyToNullableString, nil
 	}
 
 	return nil, fmt.Errorf("no matching converter found for [%v]", t)

pkg/tsdb/influxdb/flux/converters.go

@@ -1,95 +0,0 @@
-package flux
-
-import (
-	"fmt"
-	"time"
-
-	"github.com/grafana/grafana-plugin-sdk-go/data"
-)
-
-// anyToOptionalString any value as a string.
-var anyToOptionalString = data.FieldConverter{
-	OutputFieldType: data.FieldTypeNullableString,
-	Converter: func(v interface{}) (interface{}, error) {
-		if v == nil {
-			return nil, nil
-		}
-		str := fmt.Sprintf("%+v", v) // the +v adds field names
-		return &str, nil
-	},
-}
-
-// float64ToOptionalFloat64 optional float value
-var float64ToOptionalFloat64 = data.FieldConverter{
-	OutputFieldType: data.FieldTypeNullableFloat64,
-	Converter: func(v interface{}) (interface{}, error) {
-		if v == nil {
-			return nil, nil
-		}
-		val, ok := v.(float64)
-		if !ok { // or return some default value instead of erroring
-			return nil, fmt.Errorf("[float] expected float64 input but got type %T", v)
-		}
-		return &val, nil
-	},
-}
-
-// int64ToOptionalInt64 optional int value
-var int64ToOptionalInt64 = data.FieldConverter{
-	OutputFieldType: data.FieldTypeNullableInt64,
-	Converter: func(v interface{}) (interface{}, error) {
-		if v == nil {
-			return nil, nil
-		}
-		val, ok := v.(int64)
-		if !ok { // or return some default value instead of erroring
-			return nil, fmt.Errorf("[int] expected int64 input but got type %T", v)
-		}
-		return &val, nil
-	},
-}
-
-// uint64ToOptionalUInt64 optional int value
-var uint64ToOptionalUInt64 = data.FieldConverter{
-	OutputFieldType: data.FieldTypeNullableUint64,
-	Converter: func(v interface{}) (interface{}, error) {
-		if v == nil {
-			return nil, nil
-		}
-		val, ok := v.(uint64)
-		if !ok { // or return some default value instead of erroring
-			return nil, fmt.Errorf("[uint] expected uint64 input but got type %T", v)
-		}
-		return &val, nil
-	},
-}
-
-// boolToOptionalBool optional int value
-var boolToOptionalBool = data.FieldConverter{
-	OutputFieldType: data.FieldTypeNullableBool,
-	Converter: func(v interface{}) (interface{}, error) {
-		if v == nil {
-			return nil, nil
-		}
-		val, ok := v.(bool)
-		if !ok { // or return some default value instead of erroring
-			return nil, fmt.Errorf("[bool] expected bool input but got type %T", v)
-		}
-		return &val, nil
-	},
-}
-
-// timeToOptionalTime optional int value
-var timeToOptionalTime = data.FieldConverter{
-	OutputFieldType: data.FieldTypeNullableTime,
-	Converter: func(v interface{}) (interface{}, error) {
-		if v == nil {
-			return nil, nil
-		}
-		val, ok := v.(time.Time)
-		if !ok { // or return some default value instead of erroring
-			return nil, fmt.Errorf("[time] expected time input but got type %T", v)
-		}
-		return &val, nil
-	},
-}