refactor findMinGranularityDimension()

Author: KSDaemon

packages/cubejs-backend-shared/src/time.ts

@@ -12,7 +12,7 @@ export type TimeSeriesOptions = {
 };
 type ParsedInterval = Partial<Record<unitOfTime.DurationConstructor, number>>;
 
-export const GRANULARITY_LEVELS: Record<string, number> = {
+const GRANULARITY_LEVELS: Record<string, number> = {
   second: 1,
   minute: 2,
   hour: 3,
@@ -24,6 +24,55 @@ export const GRANULARITY_LEVELS: Record<string, number> = {
   MAX: 1000,
 };
 
+export type DimensionToCompareGranularity = {
+  dimension: string;
+  expressionName?: string;
+  granularityObj?: {
+    minGranularity(): string;
+  }
+};
+
+/**
+ * Actually dimensions type is (BaseDimension|BaseTimeDimension)[], but can not ref due to cyclic dependencies refs.
+ */
+export function findMinGranularityDimension(id: string, dimensions: DimensionToCompareGranularity[]): { index: number, dimension: DimensionToCompareGranularity | undefined } | null {
+  const equalIgnoreCase = (a: any, b: any): boolean => (
+    typeof a === 'string' && typeof b === 'string' && a.toUpperCase() === b.toUpperCase()
+  );
+
+  let minGranularity = GRANULARITY_LEVELS.MAX;
+  let index = -1;
+  let minGranularityIndex = -1;
+  let field;
+  let minGranularityField;
+
+  dimensions.forEach((d, i) => {
+    if (equalIgnoreCase(d.dimension, id) || equalIgnoreCase(d.expressionName, id)) {
+      field = d;
+      index = i;
+
+      if ('granularityObj' in d && d.granularityObj) {
+        const gr = GRANULARITY_LEVELS[d.granularityObj?.minGranularity()];
+        if (gr < minGranularity) {
+          minGranularityIndex = i;
+          minGranularityField = d;
+          minGranularity = gr;
+        }
+      }
+    }
+  });
+
+  if (minGranularityIndex > -1) {
+    return { index: minGranularityIndex, dimension: minGranularityField };
+  }
+
+  if (index > -1) {
+    return { index, dimension: field };
+  }
+
+  return null;
+}
+
 export const TIME_SERIES: Record<string, (range: DateRange, timestampPrecision: number) => QueryDateRange[]> = {
   day: (range: DateRange, digits) => Array.from(range.snapTo('day').by('day'))
     .map(d => [d.format(`YYYY-MM-DDT00:00:00.${'0'.repeat(digits)}`), d.format(`YYYY-MM-DDT23:59:59.${'9'.repeat(digits)}`)]),

packages/cubejs-schema-compiler/src/adapter/BaseQuery.js

@@ -22,7 +22,8 @@ import {
   localTimestampToUtc,
   timeSeries as timeSeriesBase,
   timeSeriesFromCustomInterval,
-  parseSqlInterval, GRANULARITY_LEVELS
+  parseSqlInterval,
+  findMinGranularityDimension
 } from '@cubejs-backend/shared';
 
 import { CubeSymbols } from '../compiler/CubeSymbols';
@@ -2606,31 +2607,14 @@ export class BaseQuery {
       return null;
     }
 
-    let minGranularity = GRANULARITY_LEVELS.MAX;
-    let minGranularityIndex = -1;
-
-    this.dimensionsForSelect()
+    const dimensionsForSelect = this.dimensionsForSelect()
       // Not all time dimensions are used in select list, some are just filters,
       // but they exist in this.timeDimensions, so need to filter them out
-      .filter(d => d.selectColumns())
-      .forEach((d, i) => {
-        if (equalIgnoreCase(d.dimension, id) || equalIgnoreCase(d.expressionName, id)) {
-          index = i;
-
-          const gr = GRANULARITY_LEVELS[d.granularityObj?.minGranularity()];
-          if (gr < minGranularity) {
-            minGranularityIndex = i;
-            minGranularity = gr;
-          }
-        }
-      });
+      .filter(d => d.selectColumns());
 
-    if (minGranularityIndex > -1) {
-      return minGranularityIndex + 1;
-    }
-
-    if (index > -1) {
-      return index + 1;
+    const found = findMinGranularityDimension(id, dimensionsForSelect);
+    if (found?.index > -1) {
+      return found.index + 1;
     }
 
     index = this.measures.findIndex(
@@ -2682,31 +2666,15 @@ export class BaseQuery {
       return null;
     }
 
-    let minGranularity = GRANULARITY_LEVELS.MAX;
-    let minGranularityField;
-
-    this.dimensionsForSelect()
+    const dimensionsForSelect = this.dimensionsForSelect()
       // Not all time dimensions are used in select list, some are just filters,
       // but they exist in this.timeDimensions, so need to filter them out
-      .filter(d => d.selectColumns())
-      .forEach((d) => {
-        if (equalIgnoreCase(d.dimension, id) || equalIgnoreCase(d.expressionName, id)) {
-          field = d;
-
-          const gr = GRANULARITY_LEVELS[d.granularityObj?.minGranularity()];
-          if (gr < minGranularity) {
-            minGranularityField = d;
-            minGranularity = gr;
-          }
-        }
-      });
+      .filter(d => d.selectColumns());
 
-    if (minGranularityField) {
-      return minGranularityField.aliasName();
-    }
+    const found = findMinGranularityDimension(id, dimensionsForSelect);
 
-    if (field) {
-      return field.aliasName();
+    if (found?.dimension) {
+      return found.dimension.aliasName();
     }
 
     field = this.measures.find(

packages/cubejs-schema-compiler/src/adapter/ElasticSearchQuery.ts

@@ -1,7 +1,7 @@
 /* eslint-disable max-classes-per-file */
 import R from 'ramda';
 
-import { GRANULARITY_LEVELS } from '@cubejs-backend/shared';
+import { findMinGranularityDimension } from '@cubejs-backend/shared';
 import { BaseQuery } from './BaseQuery';
 import { BaseFilter } from './BaseFilter';
 import { BaseMeasure } from './BaseMeasure';
@@ -129,33 +129,15 @@ export class ElasticSearchQuery extends BaseQuery {
       return null;
     }
 
-    let minGranularity = GRANULARITY_LEVELS.MAX;
-    let minGranularityField: BaseTimeDimension | BaseDimension | undefined;
-
-    this.dimensionsForSelect()
+    const dimensionsForSelect = this.dimensionsForSelect()
       // Not all time dimensions are used in select list, some are just filters,
       // but they exist in this.timeDimensions, so need to filter them out
-      .filter(d => d.selectColumns())
-      .forEach((d) => {
-        if (equalIgnoreCase(d.dimension, id) || equalIgnoreCase(d.expressionName, id)) {
-          field = d;
-
-          if ('granularityObj' in d && d.granularityObj) {
-            const gr = GRANULARITY_LEVELS[d.granularityObj.minGranularity()];
-            if (gr < minGranularity) {
-              minGranularityField = d;
-              minGranularity = gr;
-            }
-          }
-        }
-      });
-
-    if (minGranularityField) {
-      return minGranularityField.dimensionSql();
-    }
+      .filter(d => d.selectColumns());
 
-    if (field) {
-      return (field as BaseDimension).dimensionSql();
+    const found = findMinGranularityDimension(id, dimensionsForSelect);
+
+    if (found?.dimension) {
+      return (found.dimension as BaseDimension).dimensionSql();
     }
 
     field = this.measures.find(