Merge pull request #72 from doitintl/issue-38

Support BQ queries in variables

Author: avivl

dist/module.js

@@ -51885,12 +51885,13 @@ var BigQueryDatasource =
 /** @class */
 function () {
   /** @ngInject */
-  function BigQueryDatasource(instanceSettings, backendSrv, $q, templateSrv) {
+  function BigQueryDatasource(instanceSettings, backendSrv, $q, templateSrv, timeSrv) {
     var _this = this;
 
     this.backendSrv = backendSrv;
     this.$q = $q;
     this.templateSrv = templateSrv;
+    this.timeSrv = timeSrv;
 
     this.interpolateVariable = function (value, variable) {
       if (typeof value === "string") {
@@ -52182,6 +52183,30 @@ function () {
     });
   };
 
+  BigQueryDatasource.prototype.metricFindQuery = function (query, optionalOptions) {
+    var refId = "tempvar";
+
+    if (optionalOptions && optionalOptions.variable && optionalOptions.variable.name) {
+      refId = optionalOptions.variable.name;
+    }
+
+    var interpolatedQuery = {
+      datasourceId: this.id,
+      format: "table",
+      rawSql: this.templateSrv.replace(query, {}, this.interpolateVariable),
+      refId: refId
+    };
+    var range = this.timeSrv.timeRange();
+    var data = {
+      from: range.from.valueOf().toString(),
+      queries: [interpolatedQuery],
+      to: range.to.valueOf().toString()
+    };
+    return this.doQuery(query, refId).then(function (metricData) {
+      return _response_parser2.default.parseDataQuery(metricData, "var");
+    });
+  };
+
   BigQueryDatasource.prototype.testDatasource = function () {
     return tslib_1.__awaiter(this, void 0, void 0, function () {
       var status, message, defaultErrorMessage, path, response, error_1, path, response, error_2;
@@ -53814,9 +53839,17 @@ function () {
 
     if (format === "time_series") {
       return ResponseParser._toTimeSeries(results);
-    } else {
+    }
+
+    if (format === "table") {
       return ResponseParser._toTable(results);
     }
+
+    if (format === "var") {
+      return ResponseParser._toVar(results);
+    }
+
+    return [];
   };
 
   ResponseParser._convertValues = function (v, type) {
@@ -54003,6 +54036,21 @@ function () {
     };
   };
 
+  ResponseParser._toVar = function (results) {
+    var res = [];
+
+    for (var _i = 0, _a = results.rows; _i < _a.length; _i++) {
+      var row = _a[_i];
+      res.push(row.f[0].v);
+    }
+
+    return _lodash2.default.map(res, function (value) {
+      return {
+        text: value
+      };
+    });
+  };
+
   ResponseParser.prototype.parseTabels = function (results) {
     return this._handelWildCardTables(ResponseParser.parseData(results, "tableReference.tableId", "tableReference.tableId"));
   };

dist/module.js.map

@@ -4,6 +4,7 @@ import BigQueryQuery from "./bigquery_query";
 import ResponseParser, { IResultFormat } from "./response_parser";
 import {countBy, size} from "lodash-es";
 import {sheets} from "googleapis/build/src/apis/sheets";
+import {validate} from "@babel/types";
 
 const Shifted = "_shifted";
 function sleep(ms) {
@@ -148,7 +149,8 @@ export class BigQueryDatasource {
     instanceSettings,
     private backendSrv,
     private $q,
-    private templateSrv
+    private templateSrv,
+    private timeSrv
   ) {
     this.name = instanceSettings.name;
     this.id = instanceSettings.id;
@@ -246,6 +248,33 @@ export class BigQueryDatasource {
     );
   }
 
+  public metricFindQuery(query, optionalOptions) {
+    let refId = "tempvar";
+    if (
+      optionalOptions &&
+      optionalOptions.variable &&
+      optionalOptions.variable.name
+    ) {
+      refId = optionalOptions.variable.name;
+    }
+
+    const interpolatedQuery = {
+      datasourceId: this.id,
+      format: "table",
+      rawSql: this.templateSrv.replace(query, {}, this.interpolateVariable),
+      refId
+    };
+
+    const range = this.timeSrv.timeRange();
+    const data = {
+      from: range.from.valueOf().toString(),
+      queries: [interpolatedQuery],
+      to: range.to.valueOf().toString()
+    };
+    return this.doQuery(query, refId).then(metricData =>
+      ResponseParser.parseDataQuery(metricData, "var")
+    );
+  }
   public async testDatasource() {
     let status = "success";
     let message = "Successfully queried the BigQuery API.";

src/datasource.ts

@@ -60,9 +60,14 @@ export default class ResponseParser {
     }
     if (format === "time_series") {
       return ResponseParser._toTimeSeries(results);
-    } else {
+    }
+    if (format === "table") {
       return ResponseParser._toTable(results);
     }
+    if (format === "var") {
+      return ResponseParser._toVar(results);
+    }
+    return [];
   }
 
   public static _convertValues(v, type) {
@@ -226,6 +231,17 @@ export default class ResponseParser {
     };
   }
 
+  private static _toVar(results) {
+    const res = [];
+    for (const row of results.rows) {
+      res.push(row.f[0].v);
+    }
+
+    return _.map(res, value => {
+      return { text: value };
+    });
+  }
+
   constructor(private $q) {}
 
   public parseTabels(results): IResultFormat[] {

src/response_parser.ts

@@ -12,6 +12,7 @@ describe("BigQueryDatasource", () => {
   const templateSrv = {
     replace: jest.fn(text => text)
   };
+  const timeSrv = {};
   const raw = {
     from: moment.utc("2018-04-25 10:00"),
     to: moment.utc("2018-04-25 11:00")
@@ -32,7 +33,8 @@ describe("BigQueryDatasource", () => {
       instanceSettings,
       backendSrv,
       {},
-      templateSrv
+      templateSrv,
+      timeSrv
     );
     ctx.ds.projectName = "my project";
   });
@@ -970,14 +972,81 @@ describe("BigQueryDatasource", () => {
     };
 
     results = ResponseParser.parseDataQuery(response, "time_series");
-    it("should return a table", () => {
+    it("should return a time_series", () => {
       expect(results[0].datapoints.length).toBe(3);
       expect(results[0].datapoints[0][0]).toBe(37.7753058);
       expect(results[0].datapoints[0][1]).toBe(1521578851000);
       expect(results[0].datapoints[2][0]).toBe(37.781752);
       expect(results[0].datapoints[2][1]).toBe(1521578927000);
     });
   });
+  describe("When performing parseDataQuery for vars", () => {
+    let results;
+    const response = {
+      kind: "bigquery#queryResponse",
+      schema: {
+        fields: [
+          {
+            name: "time",
+            type: "TIMESTAMP",
+            mode: "NULLABLE"
+          },
+          {
+            name: "start_station_latitude",
+            type: "FLOAT",
+            mode: "NULLABLE"
+          }
+        ]
+      },
+      jobReference: {
+        projectId: "proj-1",
+        jobId: "job_fB4qCDAO-TKg1Orc-OrkdIRxCGN5",
+        location: "US"
+      },
+      totalRows: "3",
+      rows: [
+        {
+          f: [
+            {
+              v: "1.521578851E9"
+            },
+            {
+              v: "37.7753058"
+            }
+          ]
+        },
+        {
+          f: [
+            {
+              v: "1.521578916E9"
+            },
+            {
+              v: "37.3322326"
+            }
+          ]
+        },
+        {
+          f: [
+            {
+              v: "1.521578927E9"
+            },
+            {
+              v: "37.781752"
+            }
+          ]
+        }
+      ],
+      totalBytesProcessed: "23289520",
+      jobComplete: true,
+      cacheHit: false
+    };
+
+    results = ResponseParser.parseDataQuery(response, "var");
+    it("should return a var", () => {
+      expect(results.length).toBe(3);
+      expect(results[0].text).toBe("1.521578851E9");
+    });
+  });
 
   describe("When performing testDatasource", () => {
     let results;