@cubejs-backend/schema-compiler 0.23.8 → 0.24.1

package/CHANGELOG.md

@@ -3,6 +3,60 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [0.24.1](https://github.com/cube-js/cube.js/compare/v0.24.0...v0.24.1) (2020-11-27)
+
+
+### Bug Fixes
+
+* Specifying `dateRange` in time dimension should produce same result as `inDateRange` in filter ([a7603d7](https://github.com/cube-js/cube.js/commit/a7603d724732a51301227f68c39ba699333c0e06)), closes [#962](https://github.com/cube-js/cube.js/issues/962)
+
+
+
+
+
+# [0.24.0](https://github.com/cube-js/cube.js/compare/v0.23.15...v0.24.0) (2020-11-26)
+
+
+### Bug Fixes
+
+* Error: Type must be provided for null values. -- `null` parameter values are passed to BigQuery when used for dimensions that contain `?` ([6417e7d](https://github.com/cube-js/cube.js/commit/6417e7d120a95c4792557a4c4a0d6abb7c483db9))
+
+
+### Features
+
+* Make default refreshKey to be `every 10 seconds` and enable scheduled refresh in dev mode by default ([221003a](https://github.com/cube-js/cube.js/commit/221003aa73aa1ece3d649de9164a7379a4a690be))
+
+
+### BREAKING CHANGES
+
+* `every 10 seconds` refreshKey becomes a default refreshKey for all cubes.
+
+
+
+
+
+## [0.23.15](https://github.com/cube-js/cube.js/compare/v0.23.14...v0.23.15) (2020-11-25)
+
+
+### Bug Fixes
+
+* Error: Cannot find module 'antlr4/index' ([0d2e330](https://github.com/cube-js/cube.js/commit/0d2e33040dfea3fb80df2a1af2ccff46db0f8673))
+
+
+
+
+
+## [0.23.11](https://github.com/cube-js/cube.js/compare/v0.23.10...v0.23.11) (2020-11-13)
+
+
+### Features
+
+* **@cubejs-backend/mysql-aurora-serverless-driver:** Add a new driver to support AWS Aurora Serverless MySql ([#1333](https://github.com/cube-js/cube.js/issues/1333)) Thanks to [@kcwinner](https://github.com/kcwinner)! ([154fab1](https://github.com/cube-js/cube.js/commit/154fab1a222685e1e83d5187a4f00f745c4613a3))
+
+
+
+
+
 ## [0.23.8](https://github.com/cube-js/cube.js/compare/v0.23.7...v0.23.8) (2020-11-06)
 
 **Note:** Version bump only for package @cubejs-backend/schema-compiler

package/adapter/AWSElasticSearchQuery.js

@@ -16,8 +16,8 @@ const GRANULARITY_TO_INTERVAL = {
 };
 
 class AWSElasticSearchQueryFilter extends BaseFilter {
-  likeIgnoreCase(column, not) {
-    return `${column}${not ? ' NOT' : ''} LIKE CONCAT('%', ?, '%')`;
+  likeIgnoreCase(column, not, param) {
+    return `${column}${not ? ' NOT' : ''} LIKE CONCAT('%', ${this.allocateParam(param)}, '%')`;
   }
 }
 

package/adapter/BaseFilter.js

@@ -48,8 +48,16 @@ class BaseFilter extends BaseDimension {
       /[A-Z]/,
       (c) => (c != null ? c : '').toLowerCase()
     )}Where`;
-    const sql = this[operatorMethod](columnSql);
-    return this.query.paramAllocator.allocateParamsForQuestionString(sql, this.filterParams());
+
+    let sql = this[operatorMethod](columnSql);
+    if (sql.match(this.query.paramAllocator.paramsMatchRegex)) {
+      return sql;
+    }
+    // TODO DEPRECATED: remove and replace with error
+    // columnSql can contain `?` so allocate params first and then substitute columnSql
+    // fallback implementation for drivers that still use `?` substitution
+    sql = this[operatorMethod]('$$$COLUMN$$$');
+    return this.query.paramAllocator.allocateParamsForQuestionString(sql, this.filterParams()).replace(/\$\$\$COLUMN\$\$\$/g, columnSql);
   }
 
   measureDefinition() {
@@ -107,6 +115,37 @@ class BaseFilter extends BaseDimension {
     return '?';
   }
 
+  firstParameter() {
+    const params = this.filterParams();
+    if (!params[0]) {
+      throw new Error('Expected one parameter but nothing found');
+    }
+    return this.allocateCastParam(params[0]);
+  }
+
+  allocateCastParam(param) {
+    return this.query.paramAllocator.allocateParamsForQuestionString(this.castParameter(), [param]);
+  }
+
+  allocateTimestampParam(param) {
+    return this.query.paramAllocator.allocateParamsForQuestionString(this.query.timeStampParam(this), [param]);
+  }
+
+  allocateTimestampParams() {
+    return this.filterParams().map((p, i) => {
+      if (i > 1) {
+        throw new Error(`Expected only 2 parameters for timestamp filter but got: ${this.filterParams()}`);
+      }
+      return this.allocateTimestampParam(
+        i === 0 ? this.inDbTimeZoneDateFrom(p) : this.inDbTimeZoneDateTo(p)
+      );
+    });
+  }
+
+  allParamsRepeat(basePart) {
+    return this.filterParams().map(p => this.query.paramAllocator.allocateParamsForQuestionString(basePart, [p]));
+  }
+
   isArrayValues() {
     return Array.isArray(this.values) && this.values.length > 1;
   }
@@ -120,8 +159,7 @@ class BaseFilter extends BaseDimension {
   }
 
   likeOr(column, not) {
-    const basePart = this.likeIgnoreCase(column, not);
-    return `${join(not ? ' AND ' : ' OR ', repeat(basePart, this.filterParams().length))}${this.orIsNullCheck(column, not)}`;
+    return `${join(not ? ' AND ' : ' OR ', this.filterParams().map(p => this.likeIgnoreCase(column, not, p)))}${this.orIsNullCheck(column, not)}`;
   }
 
   orIsNullCheck(column, not) {
@@ -132,8 +170,12 @@ class BaseFilter extends BaseDimension {
     return not ? !this.valuesContainNull() : this.valuesContainNull();
   }
 
-  likeIgnoreCase(column, not) {
-    return `${column}${not ? ' NOT' : ''} ILIKE '%' || ? || '%'`;
+  likeIgnoreCase(column, not, param) {
+    return `${column}${not ? ' NOT' : ''} ILIKE '%' || ${this.allocateParam(param)} || '%'`;
+  }
+
+  allocateParam(param) {
+    return this.query.paramAllocator.allocateParam(param);
   }
 
   equalsWhere(column) {
@@ -145,11 +187,11 @@ class BaseFilter extends BaseDimension {
       return this.notSetWhere(column);
     }
 
-    return `${column} = ${this.castParameter()}${this.orIsNullCheck(column, false)}`;
+    return `${column} = ${this.firstParameter()}${this.orIsNullCheck(column, false)}`;
   }
 
   inPlaceholders() {
-    return `(${join(', ', repeat(this.castParameter(), this.filterParams().length || 1))})`;
+    return `(${join(', ', this.filterParams().map(p => this.allocateCastParam(p)))})`;
   }
 
   inWhere(column) {
@@ -165,7 +207,7 @@ class BaseFilter extends BaseDimension {
       return this.setWhere(column);
     }
 
-    return `${column} <> ${this.castParameter()}${this.orIsNullCheck(column, true)}`;
+    return `${column} <> ${this.firstParameter()}${this.orIsNullCheck(column, true)}`;
   }
 
   notInWhere(column) {
@@ -181,19 +223,19 @@ class BaseFilter extends BaseDimension {
   }
 
   gtWhere(column) {
-    return `${column} > ${this.castParameter()}`;
+    return `${column} > ${this.firstParameter()}`;
   }
 
   gteWhere(column) {
-    return `${column} >= ${this.castParameter()}`;
+    return `${column} >= ${this.firstParameter()}`;
   }
 
   ltWhere(column) {
-    return `${column} < ${this.castParameter()}`;
+    return `${column} < ${this.firstParameter()}`;
   }
 
   lteWhere(column) {
-    return `${column} <= ${this.castParameter()}`;
+    return `${column} <= ${this.firstParameter()}`;
   }
 
   expressionEqualsWhere(column) {
@@ -201,23 +243,28 @@ class BaseFilter extends BaseDimension {
   }
 
   inDateRangeWhere(column) {
-    return this.query.timeRangeFilter(column, this.query.timeStampParam(this), this.query.timeStampParam(this));
+    const [from, to] = this.allocateTimestampParams();
+    return this.query.timeRangeFilter(column, from, to);
   }
 
   notInDateRangeWhere(column) {
-    return this.query.timeNotInRangeFilter(column, this.query.timeStampParam(this), this.query.timeStampParam(this));
+    const [from, to] = this.allocateTimestampParams();
+    return this.query.timeNotInRangeFilter(column, from, to);
   }
 
   onTheDateWhere(column) {
-    return this.query.timeRangeFilter(column, this.query.timeStampParam(this), this.query.timeStampParam(this));
+    const [from, to] = this.allocateTimestampParams();
+    return this.query.timeRangeFilter(column, from, to);
   }
 
   beforeDateWhere(column) {
-    return this.query.beforeDateFilter(column, this.query.timeStampParam(this));
+    const [before] = this.allocateTimestampParams();
+    return this.query.beforeDateFilter(column, before);
   }
 
   afterDateWhere(column) {
-    return this.query.afterDateFilter(column, this.query.timeStampParam(this));
+    const [after] = this.allocateTimestampParams();
+    return this.query.afterDateFilter(column, after);
   }
 
   formatFromDate(date) {

package/adapter/BaseQuery.js

@@ -1666,25 +1666,7 @@ class BaseQuery {
         }
       }
       refreshKeyAllSetManually = false;
-      const timeDimensions =
-        !(cubeFromPath.refreshKey && cubeFromPath.refreshKey.immutable) ?
-          this.cubeEvaluator.timeDimensionPathsForCube(cube) :
-          [];
-      if (timeDimensions.length) {
-        const dimension = timeDimensions.filter(f => f.toLowerCase().indexOf('update') !== -1)[0] || timeDimensions[0];
-        const foundMainTimeDimension = this.newTimeDimension({ dimension });
-        const aggSelect = this.evaluateSymbolSqlWithContext(
-          () => this.aggSelectForDimension(cube, foundMainTimeDimension, 'max'),
-          { preAggregationQuery: true }
-        );
-        if (aggSelect) {
-          return aggSelect;
-        }
-      }
-      return this.evaluateSymbolSqlWithContext(
-        () => `select count(*) from ${this.cubeSql(cube)} ${this.asSyntaxTable} ${this.cubeAlias(cube)}`,
-        { preAggregationQuery: true }
-      );
+      return `SELECT ${this.everyRefreshKeySql(this.defaultEveryRefreshKey())}`;
     };
     const queries = cubes
       .map(cube => [cube, refreshKeyQueryByCube(cube)])
@@ -1967,6 +1949,12 @@ class BaseQuery {
     return 10;
   }
 
+  defaultEveryRefreshKey() {
+    return {
+      every: '10 seconds'
+    };
+  }
+
   preAggregationInvalidateKeyQueries(cube, preAggregation) {
     return this.cacheValue(
       ['preAggregationInvalidateKeyQueries', cube, JSON.stringify(preAggregation)],
@@ -2027,10 +2015,9 @@ class BaseQuery {
                 if (cubeFromPath.refreshKey && cubeFromPath.refreshKey.immutable) {
                   return `SELECT ${this.incrementalRefreshKey(preAggregationQueryForSql, `(${originalRefreshKey})`)}`;
                 } else if (!cubeFromPath.refreshKey) {
-                  // TODO handle WHERE while generating originalRefreshKey
-                  return refreshKeyCube === preAggregationQueryForSql.timeDimensions[0].path()[0] ?
-                    `${originalRefreshKey} WHERE ${preAggregationQueryForSql.timeDimensions[0].filterToWhere()}` :
-                    originalRefreshKey;
+                  return `SELECT ${this.everyRefreshKeySql({
+                    every: '1 hour'
+                  })}`;
                 }
                 return originalRefreshKey;
               }

package/adapter/BigqueryQuery.js

@@ -12,8 +12,8 @@ const GRANULARITY_TO_INTERVAL = {
 };
 
 class BigqueryFilter extends BaseFilter {
-  likeIgnoreCase(column, not) {
-    return `LOWER(${column})${not ? ' NOT' : ''} LIKE CONCAT('%', LOWER(?) ,'%')`;
+  likeIgnoreCase(column, not, param) {
+    return `LOWER(${column})${not ? ' NOT' : ''} LIKE CONCAT('%', LOWER(${this.allocateParam(param)}) ,'%')`;
   }
 
   castParameter() {
@@ -133,6 +133,12 @@ class BigqueryQuery extends BaseQuery {
   defaultRefreshKeyRenewalThreshold() {
     return 120;
   }
+
+  defaultEveryRefreshKey() {
+    return {
+      every: '2 minutes'
+    };
+  }
 }
 
 module.exports = BigqueryQuery;

package/adapter/ClickHouseQuery.js

@@ -13,8 +13,8 @@ const GRANULARITY_TO_INTERVAL = {
 };
 
 class ClickHouseFilter extends BaseFilter {
-  likeIgnoreCase(column, not) {
-    return `lower(${column}) ${not ? 'NOT' : ''} LIKE CONCAT('%', lower(?), '%')`;
+  likeIgnoreCase(column, not, param) {
+    return `lower(${column}) ${not ? 'NOT' : ''} LIKE CONCAT('%', lower(${this.allocateParam(param)}), '%')`;
   }
 
   castParameter() {

package/adapter/ElasticSearchQuery.js

@@ -16,8 +16,8 @@ const GRANULARITY_TO_INTERVAL = {
 };
 
 class ElasticSearchQueryFilter extends BaseFilter {
-  likeIgnoreCase(column, not) {
-    return `${not ? " NOT" : ""} MATCH(${column}, ?, 'fuzziness=AUTO:1,5')`;
+  likeIgnoreCase(column, not, param) {
+    return `${not ? " NOT" : ""} MATCH(${column}, ${this.allocateParam(param)}, 'fuzziness=AUTO:1,5')`;
   }
 }
 

package/adapter/HiveQuery.js

@@ -14,8 +14,8 @@ const GRANULARITY_TO_INTERVAL = {
 };
 
 class HiveFilter extends BaseFilter {
-  likeIgnoreCase(column, not) {
-    return `${column}${not ? ' NOT' : ''} LIKE CONCAT('%', ?, '%')`;
+  likeIgnoreCase(column, not, param) {
+    return `${column}${not ? ' NOT' : ''} LIKE CONCAT('%', ${this.allocateParam(param)}, '%')`;
   }
 }
 

package/adapter/MssqlQuery.js

@@ -43,8 +43,8 @@ class MssqlFilter extends BaseFilter {
     return typeof param === 'string' ? param.replace(/([_%])/gi, '[$1]') : param;
   }
 
-  likeIgnoreCase(column, not) {
-    return `LOWER(${column})${not ? ' NOT' : ''} LIKE CONCAT('%', LOWER(?) ,'%')`;
+  likeIgnoreCase(column, not, param) {
+    return `LOWER(${column})${not ? ' NOT' : ''} LIKE CONCAT('%', LOWER(${this.allocateParam(param)}) ,'%')`;
   }
 }
 

package/adapter/MysqlQuery.js

@@ -15,8 +15,8 @@ const GRANULARITY_TO_INTERVAL = {
 };
 
 class MysqlFilter extends BaseFilter {
-  likeIgnoreCase(column, not) {
-    return `${column}${not ? ' NOT' : ''} LIKE CONCAT('%', ?, '%')`;
+  likeIgnoreCase(column, not, param) {
+    return `${column}${not ? ' NOT' : ''} LIKE CONCAT('%', ${this.allocateParam(param)}, '%')`;
   }
 }
 

package/adapter/OracleQuery.js

@@ -20,8 +20,8 @@ class OracleFilter extends BaseFilter {
   /**
    * "ILIKE" does't support
    */
-  likeIgnoreCase(column, not) {
-    return `${column}${not ? ' NOT' : ''} LIKE '%' || ${this.castParameter()} || '%'`;
+  likeIgnoreCase(column, not, param) {
+    return `${column}${not ? ' NOT' : ''} LIKE '%' || ${this.allocateParam(param)} || '%'`;
   }
 }
 

package/adapter/ParamAllocator.js

@@ -1,6 +1,7 @@
 class ParamAllocator {
   constructor() {
     this.params = [];
+    this.paramsMatchRegex = /\$(\d+)\$/g;
   }
 
   allocateParam(param) {
@@ -16,7 +17,7 @@ class ParamAllocator {
 
   buildSqlAndParams(annotatedSql) {
     const paramsInSqlOrder = [];
-    return [annotatedSql.replace(/\$(\d+)\$/g, (match, paramIndex) => {
+    return [annotatedSql.replace(this.paramsMatchRegex, (match, paramIndex) => {
       paramsInSqlOrder.push(this.params[paramIndex]);
       return this.paramPlaceHolder(paramsInSqlOrder.length - 1);
     }), paramsInSqlOrder];

package/adapter/PrestodbQuery.js

@@ -12,8 +12,8 @@ const GRANULARITY_TO_INTERVAL = {
 };
 
 class PrestodbFilter extends BaseFilter {
-  likeIgnoreCase(column, not) {
-    return `LOWER(${column})${not ? ' NOT' : ''} LIKE CONCAT('%', LOWER(?) ,'%') ESCAPE '\\'`;
+  likeIgnoreCase(column, not, param) {
+    return `LOWER(${column})${not ? ' NOT' : ''} LIKE CONCAT('%', LOWER(${this.allocateParam(param)}) ,'%') ESCAPE '\\'`;
   }
 
   castParameter() {
@@ -81,6 +81,12 @@ class PrestodbQuery extends BaseQuery {
     return 120;
   }
 
+  defaultEveryRefreshKey() {
+    return {
+      every: '2 minutes'
+    };
+  }
+
   hllInit(sql) {
     return `cast(approx_set(${sql}) as varbinary)`;
   }

package/adapter/QueryBuilder.js

@@ -18,6 +18,7 @@ const ADAPTERS = {
   postgres,
   redshift,
   mysql,
+  mysqlauroraserverless: mysql,
   mongobi,
   mssql,
   bigquery,

package/adapter/SnowflakeQuery.js

@@ -27,6 +27,12 @@ class SnowflakeQuery extends BaseQuery {
     return 120;
   }
 
+  defaultEveryRefreshKey() {
+    return {
+      every: '2 minutes'
+    };
+  }
+
   nowTimestampSql() {
     return `CURRENT_TIMESTAMP`;
   }

package/adapter/SqliteQuery.js

@@ -14,8 +14,8 @@ const GRANULARITY_TO_INTERVAL = {
 };
 
 class SqliteFilter extends BaseFilter {
-  likeIgnoreCase(column, not) {
-    return `${column}${not ? ' NOT' : ''} LIKE '%' || ? || '%' COLLATE NOCASE`;
+  likeIgnoreCase(column, not, param) {
+    return `${column}${not ? ' NOT' : ''} LIKE '%' || ${this.allocateParam(param)} || '%' COLLATE NOCASE`;
   }
 }
 

package/compiler/CubeEvaluator.js

@@ -60,8 +60,8 @@ class CubeEvaluator extends CubeSymbols {
     }).reduce((a, b) => a.concat(b), []);
   }
 
-  cubeNamesWithRefreshKeys() {
-    return Object.keys(this.evaluatedCubes).filter(c => !!this.evaluatedCubes[c].refreshKey);
+  cubeNames() {
+    return Object.keys(this.evaluatedCubes);
   }
 
   isMeasure(measurePath) {

package/package.json

@@ -2,7 +2,7 @@
   "name": "@cubejs-backend/schema-compiler",
   "description": "Cube.js schema compiler",
   "author": "Cube Dev, Inc.",
-  "version": "0.23.8",
+  "version": "0.24.1",
   "repository": {
     "type": "git",
     "url": "https://github.com/cube-js/cube.js.git",
@@ -30,7 +30,7 @@
     "@babel/traverse": "^7.4.0",
     "@babel/types": "^7.4.0",
     "@hapi/joi": "^15.1.1",
-    "antlr4": "^4.8.0",
+    "antlr4": "4.8.0",
     "cron-parser": "^2.16.3",
     "humps": "^2.0.1",
     "inflection": "^1.12.0",
@@ -62,5 +62,5 @@
     "uuid": "^3.3.2"
   },
   "license": "Apache-2.0",
-  "gitHead": "527077fabdf797bcdfb0d5619e21d9432b50f15b"
+  "gitHead": "0479050307f08ca69f4fdaee2d08d3e4f39453e6"
 }

package/test/integration/postgres/PreAggregationsTest.js

@@ -138,6 +138,14 @@ describe('PreAggregations', function test() {
           granularity: 'hour',
           partitionGranularity: 'hour'
         },
+        partitionedHourlyForRange: {
+          type: 'rollup',
+          measureReferences: [checkinsTotal],
+          dimensionReferences: [source, createdAt],
+          timeDimensionReference: createdAt,
+          granularity: 'hour',
+          partitionGranularity: 'hour'
+        },
         ratio: {
           type: 'rollup',
           measureReferences: [checkinsTotal, uniqueSourceCount],
@@ -599,7 +607,7 @@ describe('PreAggregations', function test() {
     const preAggregationsDescription = query.preAggregations.preAggregationsDescription();
     console.log(JSON.stringify(preAggregationsDescription, null, 2));
 
-    preAggregationsDescription[0].invalidateKeyQueries[0][0].should.match(/>=/);
+    preAggregationsDescription[0].invalidateKeyQueries[0][0].should.match(/FLOOR/);
 
     return dbRunner.testQueries(tempTablePreAggregations(preAggregationsDescription).concat([
       query.buildSqlAndParams()
@@ -795,6 +803,54 @@ describe('PreAggregations', function test() {
     });
   }));
 
+  it('partitioned inDateRange', () => compiler.compile().then(() => {
+    const query = new PostgresQuery({ joinGraph, cubeEvaluator, compiler }, {
+      measures: [
+        'visitors.checkinsTotal'
+      ],
+      dimensions: [
+        'visitors.source'
+      ],
+      timezone: 'America/Los_Angeles',
+      preAggregationsSchema: '',
+      filters: [{
+        member: 'visitors.createdAt',
+        operator: 'inDateRange',
+        values: ['2016-12-30', '2017-01-05']
+      }],
+      order: [{
+        id: 'visitors.checkinsTotal'
+      }],
+    });
+
+    const queryAndParams = query.buildSqlAndParams();
+    console.log(queryAndParams);
+    const preAggregationsDescription = query.preAggregations.preAggregationsDescription();
+    console.log(JSON.stringify(preAggregationsDescription, null, 2));
+
+    const queries = tempTablePreAggregations(preAggregationsDescription);
+
+    console.log(JSON.stringify(queries.concat(queryAndParams)));
+
+    return dbRunner.testQueries(
+      queries.concat([queryAndParams]).map(q => replaceTableName(q, preAggregationsDescription, 12342))
+    ).then(res => {
+      console.log(JSON.stringify(res));
+      res.should.be.deepEqual(
+        [
+          {
+            'visitors__source': 'google',
+            'visitors__checkins_total': '1'
+          },
+          {
+            'visitors__source': 'some',
+            'visitors__checkins_total': '5'
+          }
+        ]
+      );
+    });
+  }));
+
   it('partitioned hourly', () => compiler.compile().then(() => {
     const query = new PostgresQuery({ joinGraph, cubeEvaluator, compiler }, {
       measures: [

package/test/integration/postgres/SQLGenerationTest.js

@@ -164,6 +164,10 @@ describe('SQL Generation', function test() {
           type: \`geo\`,
           latitude: { sql: \`latitude\` },
           longitude: { sql: \`longitude\` }
+        },
+        questionMark: {
+          sql: \`replace('some string question string???', 'string', 'with some ???')\`,
+          type: \`string\`
         }
       }
     })
@@ -1646,6 +1650,34 @@ describe('SQL Generation', function test() {
     ])
   );
 
+  it(
+    'question mark filter',
+    () => runQueryTest({
+      measures: ['visitors.visitor_count'],
+      dimensions: [],
+      timeDimensions: [],
+      timezone: 'America/Los_Angeles',
+      filters: [{
+        or: [{
+          member: 'visitors.questionMark',
+          operator: 'contains',
+          values: ['with some']
+        }, {
+          member: 'visitors.questionMark',
+          operator: 'equals',
+          values: [null]
+        }, {
+          member: 'visitors.questionMark',
+          operator: 'equals',
+          values: [null, 'with some']
+        }]
+      }],
+      order: []
+    }, [
+      { 'visitors__visitor_count': '6' }
+    ])
+  );
+
   const baseQuery = {
     measures: [
       'visitors.countDistinctApproxRolling'