Add dynamic query variables

go.mod

@@ -1,9 +1,8 @@
-module github.com/grafana/simple-datasource-backend
+module github.com/rockset/rockset-grafana-backend
 
 go 1.14
 
 require (
-	github.com/davecgh/go-spew v1.1.1
-	github.com/grafana/grafana-plugin-sdk-go v0.65.0
+	github.com/grafana/grafana-plugin-sdk-go v0.113.0
 	github.com/rockset/rockset-go-client v0.9.2
 )

pkg/rockset.go

@@ -224,6 +224,7 @@ func makeFrame(timeField, valueField, labelColumn, label string, qr api.QueryRes
 
   var times []time.Time
   var values []float64
+  var strValues []string
 
   var labels map[string]string
   // empty label means there is no label column and labels should use the zero value, which is nil
@@ -253,12 +254,23 @@ func makeFrame(timeField, valueField, labelColumn, label string, qr api.QueryRes
 
     // TODO: this is a bit naïve and could be improved, as the rows can be of different types
     f, ok := v.(float64)
+    if ok {
+      values = append(values, f)
+    }
     if !ok {
       // TODO: is there a way to send warnings back to the Grafana UI?
-      log.DefaultLogger.Error("could cast to float64", "column", valueField, "value", v)
-      continue
+      log.DefaultLogger.Error("could not cast to float64", "column", valueField, "value", v)
+      g, strOk := v.(string)
+      if strOk {
+        strValues = append(strValues, g)
+      }
+      if !strOk {
+        log.DefaultLogger.Error("could not cast to float64 or string", "column", valueField, "value", v)
+        continue
+      }
+
     }
-    values = append(values, f)
+
 
     // TODO: time conversion could be cached as it is parsed each call to makeFrame
     t, err := parseTime(m, timeField)
@@ -271,8 +283,11 @@ func makeFrame(timeField, valueField, labelColumn, label string, qr api.QueryRes
   // add the time dimension
   frame.Fields = append(frame.Fields, data.NewField("time", labels, times))
   // add values
-  frame.Fields = append(frame.Fields, data.NewField(valueField, labels, values))
-
+  if len(values) > 0 {
+    frame.Fields = append(frame.Fields, data.NewField(valueField, labels, values))
+  } else if len(strValues) > 0 {
+    frame.Fields = append(frame.Fields, data.NewField(valueField, labels, strValues))
+  }
   return frame, nil
 }
 
@@ -285,7 +300,7 @@ func parseTime(fields map[string]interface{}, key string) (time.Time, error) {
 
   k, ok := ifc.(string)
   if !ok {
-    return time.Time{}, fmt.Errorf("could cast %s to string", key)
+    return time.Time{}, fmt.Errorf("could not cast %s to string", key)
   }
 
   t, err := time.Parse(time.RFC3339Nano, k)

src/DataSource.tsx

@@ -0,0 +1,50 @@
+import {
+  DataSourceInstanceSettings,
+  DataQueryRequest,
+  DataQueryResponse,
+  MetricFindValue,
+  DataFrame,
+} from '@grafana/data';
+import { DataSourceWithBackend, getTemplateSrv } from '@grafana/runtime';
+import { RocksetDataSourceOptions, RocksetQuery, MyVariableQuery } from './types';
+
+export class DataSource extends DataSourceWithBackend<RocksetQuery, RocksetDataSourceOptions> {
+  constructor(instanceSettings: DataSourceInstanceSettings<RocksetDataSourceOptions>) {
+    super(instanceSettings);
+  }
+
+  async metricFindQuery?(query: MyVariableQuery, options?: any): Promise<MetricFindValue[]> {
+    const request = {
+      targets: [
+        {
+          queryText: query.rawQuery,
+          queryTimeField: '_event_time',
+          queryValueField: 'value',
+          refId: 'metricFindQuery',
+        },
+      ],
+    } as DataQueryRequest<MyVariableQuery>;
+
+    let res: DataQueryResponse;
+
+    try {
+      res = await this.query(request).toPromise();
+    } catch (err) {
+      return Promise.reject(err);
+    }
+
+    if (!res.data.length || !res.data[0].fields.length) {
+      return [];
+    }
+
+    return (res.data[0] as DataFrame).fields[1].values.toArray().map(_ => ({ text: _.toString() }));
+  }
+
+  applyTemplateVariables(query: RocksetQuery) {
+    const templateSrv = getTemplateSrv();
+    return {
+      ...query,
+      queryText: query.queryText ? templateSrv.replace(query.queryText) : '',
+    };
+  }
+}

src/VariableQueryEditor.tsx

@@ -0,0 +1,36 @@
+import React, { useState } from 'react';
+import { MyVariableQuery } from './types';
+
+interface VariableQueryProps {
+  query: MyVariableQuery;
+  onChange: (query: MyVariableQuery, definition: string) => void;
+}
+
+export const VariableQueryEditor: React.FC<VariableQueryProps> = ({ onChange, query }) => {
+  const [state, setState] = useState(query);
+
+  const saveQuery = () => {
+    onChange(state, `${state.query}`);
+  };
+
+  const handleChange = (event: React.FormEvent<HTMLInputElement>) =>
+    setState({
+      ...state,
+      [event.currentTarget.name]: event.currentTarget.value,
+    });
+
+  return (
+    <>
+      <div className="gf-form">
+        <span className="gf-form-label width-10">Query</span>
+        <input
+          name="rawQuery"
+          className="gf-form-input"
+          onBlur={saveQuery}
+          onChange={handleChange}
+          value={state.rawQuery}
+        />
+      </div>
+    </>
+  );
+};

src/module.ts

@@ -3,7 +3,9 @@ import { DataSource } from './DataSource';
 import { ConfigEditor } from './ConfigEditor';
 import { QueryEditor } from './QueryEditor';
 import { RocksetQuery, RocksetDataSourceOptions } from './types';
+import { VariableQueryEditor } from './VariableQueryEditor';
 
 export const plugin = new DataSourcePlugin<DataSource, RocksetQuery, RocksetDataSourceOptions>(DataSource)
   .setConfigEditor(ConfigEditor)
-  .setQueryEditor(QueryEditor);
+  .setQueryEditor(QueryEditor)
+  .setVariableQueryEditor(VariableQueryEditor);

src/types.ts

@@ -43,3 +43,9 @@ export interface RocksetDataSourceOptions extends DataSourceJsonData {
 export interface RocksetSecureJsonData {
   apiKey?: string;
 }
+
+export interface MyVariableQuery extends RocksetQuery {
+  namespace: string;
+  rawQuery: string;
+  query: string;
+}