dsl-to-sql 1.0.0-fabric-1p-development.1

package/src/epm-query-builder/base/SharedFilterBuilder.ts

@@ -0,0 +1,544 @@
+import {
+  FilterConfig,
+  RangeFilter,
+  RankingConfig,
+} from '@epm-query-builder/types/query-builder-types';
+import { BaseUtilities } from '@epm-query-builder/base/BaseUtilities';
+import * as ColumnRefUtils from '@epm-query-builder/base/ColumnRefUtils';
+
+export class SharedFilterBuilder {
+  private static mapToCanonicalOperator(op: string): string {
+    const norm = (op || '')
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/g, '_')
+      .replace(/^_+|_+$/g, '');
+    switch (norm) {
+      case 'contains':
+        return 'CONTAINS';
+      case 'does_not_contain':
+      case 'does_not_contains':
+      case 'not_contains':
+      case 'not_contain':
+        return 'DOES_NOT_CONTAIN';
+      case 'starts_with':
+        return 'STARTS_WITH';
+      case 'does_not_start_with':
+      case 'does_not_starts_with':
+      case 'not_starts_with':
+      case 'not_start_with':
+        return 'DOES_NOT_START_WITH';
+      case 'ends_with':
+        return 'ENDS_WITH';
+      case 'does_not_end_with':
+      case 'not_ends_with':
+      case 'not_end_with':
+        return 'DOES_NOT_END_WITH';
+      case 'equals':
+      case 'is_equal_to':
+      case 'is':
+        return 'EQUALS';
+      case 'not_equals':
+      case 'is_not_equal_to':
+      case 'is_not':
+        return 'NOT_EQUALS';
+      case 'is_blank':
+      case 'blank':
+        return 'IS_BLANK';
+      case 'is_not_blank':
+      case 'not_blank':
+        return 'IS_NOT_BLANK';
+      default:
+        return norm.toUpperCase();
+    }
+  }
+  static buildRangeCondition(column: string, range: RangeFilter): string {
+    const parts: string[] = [];
+
+    if (range.from !== undefined && range.fromCondition) {
+      parts.push(this.buildRangeOperatorCondition(column, range.fromCondition, range.from));
+    }
+
+    if (range.to !== undefined && range.toCondition) {
+      parts.push(this.buildRangeOperatorCondition(column, range.toCondition, range.to));
+    }
+
+    if (range.operator && range.value !== undefined) {
+      parts.push(this.buildRangeOperatorCondition(column, range.operator, range.value));
+    }
+
+    if (parts.length === 0) return '';
+
+    const joiner = (range.logicalOperator || 'AND').toUpperCase() === 'OR' ? 'OR' : 'AND';
+    return parts.length === 1 ? parts[0] : `(${parts.join(` ${joiner} `)})`;
+  }
+
+  private static buildRangeOperatorCondition(
+    column: string,
+    operator: string,
+    value: string | number | boolean,
+  ): string {
+    const operatorCode = this.mapToCanonicalOperator(operator);
+
+    const escapedValue = String(value).replace(/'/g, "''");
+
+    switch (operatorCode) {
+      case 'CONTAINS':
+        return `LOWER(${column}) LIKE LOWER('%${escapedValue}%')`;
+      case 'DOES_NOT_CONTAIN':
+      case 'NOT_CONTAINS':
+      case 'NOT CONTAINS':
+        return `LOWER(${column}) NOT LIKE LOWER('%${escapedValue}%')`;
+      case 'STARTS_WITH':
+        return `LOWER(${column}) LIKE LOWER('${escapedValue}%')`;
+      case 'DOES_NOT_START_WITH':
+      case 'NOT_STARTS_WITH':
+      case 'NOT STARTS WITH':
+        return `LOWER(${column}) NOT LIKE LOWER('${escapedValue}%')`;
+      case 'ENDS_WITH':
+        return `LOWER(${column}) LIKE LOWER('%${escapedValue}')`;
+      case 'DOES_NOT_END_WITH':
+      case 'NOT_ENDS_WITH':
+      case 'NOT ENDS WITH':
+        return `LOWER(${column}) NOT LIKE LOWER('%${escapedValue}')`;
+      case 'EQUALS':
+      case 'IS_EQUAL_TO':
+      case 'IS':
+        return BaseUtilities.buildFilterConditionForOperator(column, 'IS_EQUAL_TO', value);
+      case 'NOT_EQUALS':
+      case 'IS_NOT_EQUAL_TO':
+      case 'IS_NOT':
+        return BaseUtilities.buildFilterConditionForOperator(column, 'IS_NOT_EQUAL_TO', value);
+      case 'IS_GREATER_THAN':
+        return BaseUtilities.buildFilterConditionForOperator(column, 'IS_GREATER_THAN', value);
+      case 'IS_GREATER_THAN_OR_EQUAL_TO':
+        return BaseUtilities.buildFilterConditionForOperator(
+          column,
+          'IS_GREATER_THAN_OR_EQUAL_TO',
+          value,
+        );
+      case 'IS_LESS_THAN':
+        return BaseUtilities.buildFilterConditionForOperator(column, 'IS_LESS_THAN', value);
+      case 'IS_LESS_THAN_OR_EQUAL_TO':
+        return BaseUtilities.buildFilterConditionForOperator(
+          column,
+          'IS_LESS_THAN_OR_EQUAL_TO',
+          value,
+        );
+      case 'IS_BLANK':
+        return BaseUtilities.buildFilterConditionForOperator(column, 'IS_BLANK', '');
+      case 'IS_NOT_BLANK':
+        return BaseUtilities.buildFilterConditionForOperator(column, 'IS_NOT_BLANK', '');
+      case 'IS_EMPTY':
+        return `TRIM(${column}) = ''`;
+      case 'IS_NOT_EMPTY':
+        return `TRIM(${column}) != ''`;
+      default:
+        return `LOWER(${column}) LIKE LOWER('%${escapedValue}%')`;
+    }
+  }
+
+  static buildRangeFilter(filter: FilterConfig): string {
+    if (!filter.columnNames?.length || !filter.rangeFilter?.length) {
+      return '';
+    }
+
+    const column = this.getColumnReference(filter);
+    const conditions = filter.rangeFilter
+      .map((range) => this.buildRangeCondition(column, range))
+      .filter((condition) => condition);
+
+    return BaseUtilities.combineConditions(
+      conditions,
+      (filter.logicalOperator as 'AND' | 'OR') || 'AND',
+    );
+  }
+
+  static buildValuesFilter(filter: FilterConfig): string {
+    if (!filter.columnNames?.length || !filter.valuesFilter?.length) {
+      return '';
+    }
+
+    const column = this.getColumnReference(filter);
+    const values = filter.valuesFilter
+      .flatMap((vf) => (Array.isArray(vf.id) ? vf.id : [vf.id]))
+      .filter((v) => v !== undefined);
+
+    if (values.length === 0) return '';
+
+    const operator =
+      filter.valuesFilterApplicationType?.toUpperCase() === 'EXCLUDE' ? 'NOT IN' : 'IN';
+    const valueList = values.map((v) => BaseUtilities.formatValue(v.toString())).join(',');
+
+    return `${column} ${operator} (${valueList})`;
+  }
+
+  static buildRankingFilter(filter: FilterConfig): string {
+    const rankingConfigs =
+      filter.rankingFilter || (filter.rankingConfig ? [filter.rankingConfig] : []);
+
+    if (!rankingConfigs.length || !filter.columnNames?.length) {
+      return '';
+    }
+
+    const conditions = rankingConfigs.map((rankingConfig) =>
+      this.buildSingleRankingCondition(filter, rankingConfig),
+    );
+
+    return BaseUtilities.combineConditions(
+      conditions,
+      (filter.logicalOperator as 'AND' | 'OR') || 'AND',
+    );
+  }
+
+  private static buildSingleRankingCondition(
+    filter: FilterConfig,
+    rankingConfig: RankingConfig,
+  ): string {
+    const column = filter.columnNames![0];
+    const tableName = filter.tableNames?.[0] || rankingConfig.rankByTableName || '';
+
+    const rankByColumnId =
+      rankingConfig.rankByColumnId ||
+      `${rankingConfig.rankByTableName || ''}[${rankingConfig.rankByColumnName || column}]`;
+    const actualColumnId = BaseUtilities.extractColumnIdFromHierarchy(rankByColumnId);
+
+    const rankByColumnRef = tableName
+      ? BaseUtilities.buildColumnReference(tableName, actualColumnId)
+      : `"${actualColumnId}"`;
+
+    const aggregationType = BaseUtilities.mapAggregationType(
+      rankingConfig.rankByAggregationType || 'SUM',
+    );
+    const orderDirection = rankingConfig.type === 'TOP' ? 'DESC' : 'ASC';
+
+    const measureExpression =
+      aggregationType !== 'NONE' ? `${aggregationType}(${rankByColumnRef})` : rankByColumnRef;
+
+    if (rankingConfig.isPercentage) {
+      const percentileValue = rankingConfig.value / 100;
+      return `PERCENT_RANK() OVER (ORDER BY ${measureExpression} ${orderDirection}) <= ${percentileValue}`;
+    } else {
+      return `ROW_NUMBER() OVER (ORDER BY ${measureExpression} ${orderDirection}) <= ${rankingConfig.value}`;
+    }
+  }
+
+  static buildSearchFilter(filter: FilterConfig): string {
+    if (!filter.columnNames?.length || !filter.searchConditions?.length) {
+      return '';
+    }
+
+    const column = this.getColumnReference(filter);
+    const conditions = filter.searchConditions.map((condition) => {
+      const operatorCode = this.mapToCanonicalOperator(condition.operator || '');
+      const rawValue = String(condition.value ?? '');
+      const escapedValue = rawValue.replace(/'/g, "''");
+
+      switch (operatorCode) {
+        case 'CONTAINS':
+          return `LOWER(${column}) LIKE LOWER('%${escapedValue}%')`;
+        case 'DOES_NOT_CONTAIN':
+          return `LOWER(${column}) NOT LIKE LOWER('%${escapedValue}%')`;
+        case 'STARTS_WITH':
+          return `LOWER(${column}) LIKE LOWER('${escapedValue}%')`;
+        case 'DOES_NOT_START_WITH':
+          return `LOWER(${column}) NOT LIKE LOWER('${escapedValue}%')`;
+        case 'ENDS_WITH':
+          return `LOWER(${column}) LIKE LOWER('%${escapedValue}')`;
+        case 'DOES_NOT_END_WITH':
+          return `LOWER(${column}) NOT LIKE LOWER('%${escapedValue}')`;
+        case 'EQUALS':
+          return `${column} = ${BaseUtilities.formatValue(rawValue)}`;
+        case 'NOT_EQUALS':
+          return `${column} != ${BaseUtilities.formatValue(rawValue)}`;
+        case 'IS_BLANK':
+          return `${column} IS NULL`;
+        case 'IS_NOT_BLANK':
+          return `${column} IS NOT NULL`;
+        case 'IS_EMPTY':
+          return `TRIM(${column}) = ''`;
+        case 'IS_NOT_EMPTY':
+          return `TRIM(${column}) != ''`;
+        default:
+          return `LOWER(${column}) LIKE LOWER('%${escapedValue}%')`;
+      }
+    });
+
+    return BaseUtilities.combineConditions(conditions, 'AND');
+  }
+
+  static buildBlankFilter(filter: FilterConfig): string {
+    if (!filter.columnNames?.length || !filter.blankFilterConfig) {
+      return '';
+    }
+
+    const column = this.getColumnReference(filter);
+    const blankConfig = filter.blankFilterConfig;
+
+    if (blankConfig.operator === 'IS_BLANK') {
+      if (blankConfig.treatEmptyStringAsBlank) {
+        return `(${column} IS NULL OR TRIM(${column}) = '')`;
+      } else {
+        return `${column} IS NULL`;
+      }
+    } else {
+      if (blankConfig.treatEmptyStringAsBlank) {
+        return `(${column} IS NOT NULL AND TRIM(${column}) != '')`;
+      } else {
+        return `${column} IS NOT NULL`;
+      }
+    }
+  }
+
+  static buildTupleFilter(filter: FilterConfig): string {
+    if (!filter.columnNames?.length || !filter.valuesFilter?.length) {
+      return '';
+    }
+
+    const columns = filter.columnNames;
+    const tupleConditions: string[] = [];
+
+    filter.valuesFilter.forEach((valueItem) => {
+      if (Array.isArray(valueItem.id)) {
+        const tupleValues = valueItem.id
+          .map((id, index) => `${columns[index]} = ${BaseUtilities.formatValue(id.toString())}`)
+          .join(' AND ');
+        tupleConditions.push(`(${tupleValues})`);
+      }
+    });
+
+    if (tupleConditions.length === 0) return '';
+
+    const isInclude = filter.valuesFilterApplicationType === 'INCLUDE';
+    if (tupleConditions.length === 1) {
+      return tupleConditions[0];
+    }
+    const joiner = isInclude ? ' OR ' : ' AND NOT ';
+    const combined = tupleConditions.join(joiner);
+    return `(${combined})`;
+  }
+
+  static buildRelativePeriodFilter(filter: FilterConfig): string {
+    if (!filter.columnNames?.length || !filter.relativePeriodFilter) {
+      return '';
+    }
+
+    const column = this.getColumnReference(filter);
+    return this.buildRelativePeriodCondition(column, filter.relativePeriodFilter);
+  }
+
+  static buildDateHierarchyFilter(filter: FilterConfig): string {
+    if (!filter.columnNames?.length || !filter.dateHierarchyConfig) {
+      return '';
+    }
+
+    const tableName = filter.tableNames?.[0];
+    const column = BaseUtilities.buildColumnReference(tableName, filter.columnNames[0]);
+    const hierarchyConfig = filter.dateHierarchyConfig;
+
+    if (!hierarchyConfig.level) {
+      return `${column} IS NOT NULL`;
+    }
+
+    if (!hierarchyConfig.values?.length) {
+      let hierarchyFunction: string;
+      switch (hierarchyConfig.level) {
+        case 'YEAR':
+          hierarchyFunction = `EXTRACT(YEAR FROM ${column})`;
+          break;
+        case 'QUARTER':
+          hierarchyFunction = `EXTRACT(QUARTER FROM ${column})`;
+          break;
+        case 'MONTH':
+          hierarchyFunction = `EXTRACT(MONTH FROM ${column})`;
+          break;
+        case 'DAY':
+          hierarchyFunction = `EXTRACT(DAY FROM ${column})`;
+          break;
+        case 'WEEK':
+          hierarchyFunction = `EXTRACT(WEEK FROM ${column})`;
+          break;
+        case 'DAYOFWEEK':
+          hierarchyFunction = `EXTRACT(DAYOFWEEK FROM ${column})`;
+          break;
+        default:
+          return `${column} IS NOT NULL`;
+      }
+      return `${hierarchyFunction} IS NOT NULL`;
+    }
+
+    let hierarchyFunction: string;
+    switch (hierarchyConfig.level) {
+      case 'YEAR':
+        hierarchyFunction = `EXTRACT(YEAR FROM ${column})`;
+        break;
+      case 'QUARTER':
+        hierarchyFunction = `EXTRACT(QUARTER FROM ${column})`;
+        break;
+      case 'MONTH':
+        hierarchyFunction = `EXTRACT(MONTH FROM ${column})`;
+        break;
+      case 'DAY':
+        hierarchyFunction = `EXTRACT(DAY FROM ${column})`;
+        break;
+      case 'WEEK':
+        hierarchyFunction = `EXTRACT(WEEK FROM ${column})`;
+        break;
+      case 'DAYOFWEEK':
+        hierarchyFunction = `EXTRACT(DAYOFWEEK FROM ${column})`;
+        break;
+      default:
+        return `${column} IS NOT NULL`;
+    }
+
+    if (hierarchyConfig.values.length === 1) {
+      return `${hierarchyFunction} = ${hierarchyConfig.values[0]}`;
+    } else {
+      const valuesList = hierarchyConfig.values.join(', ');
+      return `${hierarchyFunction} IN (${valuesList})`;
+    }
+  }
+
+  static buildFieldParameterFilter(filter: FilterConfig): string {
+    if (!filter.fieldParameterMapping) {
+      return '';
+    }
+
+    const mapping = filter.fieldParameterMapping;
+    if (!mapping.targetField) {
+      return '';
+    }
+
+    const tableName = mapping.targetTable;
+    const column = BaseUtilities.buildColumnReference(tableName, mapping.targetField);
+
+    if (mapping.filterValues?.length) {
+      if (mapping.filterValues.length === 1) {
+        return `${column} = '${mapping.filterValues[0]}'`;
+      } else {
+        const valuesList = mapping.filterValues.map((v) => `'${v}'`).join(', ');
+        return `${column} IN (${valuesList})`;
+      }
+    }
+
+    return `${column} IS NOT NULL`;
+  }
+
+  static buildDateFilter(filter: FilterConfig): string {
+    if (!filter.dateRangeFilter?.length) return '';
+
+    const column = this.getColumnReference(filter);
+    const conditions = filter.dateRangeFilter.map((dateRange) => {
+      const startDate = BaseUtilities.stringToDate(dateRange.startDate);
+      const endDate = BaseUtilities.stringToDate(dateRange.endDate);
+      return `${column} BETWEEN ${startDate} AND ${endDate}`;
+    });
+
+    return BaseUtilities.combineConditions(conditions, 'AND');
+  }
+
+  private static getColumnReference(filter: FilterConfig): string {
+    const columnId = filter.columnIds?.[0];
+    const columnFromName = filter.columnNames?.[0];
+    const tableName =
+      filter.tableNames?.[0] ||
+      (columnId ? ColumnRefUtils.getTableNameFromId(columnId) || undefined : undefined);
+
+    if (columnId) {
+      const actualId = BaseUtilities.extractColumnIdFromHierarchy(columnId);
+      const columnOnly = ColumnRefUtils.getColumnNameFromId(actualId);
+      return tableName
+        ? BaseUtilities.buildColumnReference(tableName, columnOnly)
+        : `"${columnOnly}"`;
+    }
+
+    if (columnFromName) {
+      return tableName
+        ? BaseUtilities.buildColumnReference(tableName, columnFromName)
+        : `"${columnFromName}"`;
+    }
+    return '';
+  }
+
+  static buildFilterCondition(filter: FilterConfig): string {
+    if (!filter) return '';
+
+    switch (filter.filterType?.toUpperCase()) {
+      case 'VALUES':
+        return this.buildValuesFilter(filter);
+      case 'RANGE':
+        return this.buildRangeFilter(filter);
+      case 'DATE':
+      case 'DATE_RANGE':
+        return this.buildDateFilter(filter);
+      case 'RANKING':
+        return this.buildRankingFilter(filter);
+      case 'SEARCH':
+        return this.buildSearchFilter(filter);
+      case 'BLANK':
+        return this.buildBlankFilter(filter);
+      case 'TUPLE':
+        return this.buildTupleFilter(filter);
+      case 'RELATIVE_PERIOD':
+        return this.buildRelativePeriodFilter(filter);
+      case 'DATE_HIERARCHY':
+        return this.buildDateHierarchyFilter(filter);
+      case 'FIELD_PARAMETER':
+        return this.buildFieldParameterFilter(filter);
+      default:
+        return '';
+    }
+  }
+
+  static buildRelativePeriodCondition(
+    column: string,
+    config: { duration: number; period: string; relativeDateFilter: string },
+  ): string {
+    const now = 'CURRENT_DATE';
+    const duration = config.duration;
+    const period = config.period;
+
+    switch (config.relativeDateFilter) {
+      case 'IS_IN_THE_LAST':
+        switch (period) {
+          case 'DAYS':
+            return `${column} >= ${now} - INTERVAL '${duration} days'`;
+          case 'WEEKS':
+            return `${column} >= ${now} - INTERVAL '${duration} weeks'`;
+          case 'MONTHS':
+            return `${column} >= ${now} - INTERVAL '${duration} months'`;
+          case 'YEARS':
+            return `${column} >= ${now} - INTERVAL '${duration} years'`;
+          default:
+            return `${column} >= ${now} - INTERVAL '${duration} days'`;
+        }
+      case 'IS_IN_THE_NEXT':
+        switch (period) {
+          case 'DAYS':
+            return `${column} <= ${now} + INTERVAL '${duration} days'`;
+          case 'WEEKS':
+            return `${column} <= ${now} + INTERVAL '${duration} weeks'`;
+          case 'MONTHS':
+            return `${column} <= ${now} + INTERVAL '${duration} months'`;
+          case 'YEARS':
+            return `${column} <= ${now} + INTERVAL '${duration} years'`;
+          default:
+            return `${column} <= ${now} + INTERVAL '${duration} days'`;
+        }
+      case 'IS_IN_THIS':
+        switch (period) {
+          case 'DAYS':
+            return `DATE_TRUNC('day', ${column}) = DATE_TRUNC('day', ${now})`;
+          case 'WEEKS':
+            return `DATE_TRUNC('week', ${column}) = DATE_TRUNC('week', ${now})`;
+          case 'MONTHS':
+            return `DATE_TRUNC('month', ${column}) = DATE_TRUNC('month', ${now})`;
+          case 'YEARS':
+            return `DATE_TRUNC('year', ${column}) = DATE_TRUNC('year', ${now})`;
+          default:
+            return `DATE_TRUNC('day', ${column}) = DATE_TRUNC('day', ${now})`;
+        }
+      default:
+        return `${column} = ${now}`;
+    }
+  }
+}

package/src/epm-query-builder/constants/Aggregations.ts

@@ -0,0 +1,16 @@
+export const AGGREGATION_TYPE_MAP: Record<string, string> = {
+  FIRST: 'MIN',
+  LAST: 'MAX',
+  STANDARD_DEVIATION: 'STDDEV',
+  VARIANCE: 'VAR',
+  AVERAGE: 'AVG',
+  COUNT_DISTINCT: 'COUNT',
+  DISTINCT_COUNT: 'COUNT',
+  COUNT: 'COUNT',
+};
+
+export function mapAggregationType(aggregationType?: string): string {
+  if (!aggregationType) return 'SUM';
+  const key = aggregationType.toUpperCase();
+  return AGGREGATION_TYPE_MAP[key] || key;
+}

package/src/epm-query-builder/constants/Database.ts

@@ -0,0 +1,6 @@
+// list of supported databases for epm query builder
+export const DATABASE_TYPES = {
+  DUCKDB: 'duckdb',
+} as const;
+
+export type DatabaseType = (typeof DATABASE_TYPES)[keyof typeof DATABASE_TYPES];

package/src/epm-query-builder/constants/Source.ts

@@ -0,0 +1,7 @@
+// Source types for epm query builder
+export const SOURCE_TYPES = {
+  BLEND: 'blend',
+  XMLA: 'xmla',
+} as const;
+
+export type SourceType = (typeof SOURCE_TYPES)[keyof typeof SOURCE_TYPES];

package/src/epm-query-builder/dialects/duckdb/DuckDbAdvancedAggregations.ts

@@ -0,0 +1,67 @@
+import {
+  MeasureConfig,
+  EpmQueryBuilderOptions,
+} from '@epm-query-builder/types/query-builder-types';
+import { BaseAdvancedAggregations } from '@epm-query-builder/base/BaseAdvancedAggregations';
+import { BaseUtilities } from '@epm-query-builder/base/BaseUtilities';
+
+export class DuckDbAdvancedAggregations extends BaseAdvancedAggregations {
+  constructor(options: EpmQueryBuilderOptions) {
+    super(options);
+  }
+
+  buildHistogramAggregation(measure: MeasureConfig, binCount = 10): string {
+    const columnRef = BaseUtilities.buildColumnReference(
+      measure.tableName,
+      measure.columnName || measure.id,
+    );
+
+    return `HISTOGRAM(${columnRef}) WITH ${binCount} BINS`;
+  }
+
+  buildReservoirSample(measure: MeasureConfig, sampleSize: number): string {
+    const columnRef = BaseUtilities.buildColumnReference(
+      measure.tableName,
+      measure.columnName || measure.id,
+    );
+
+    return `RESERVOIR_SAMPLE(${columnRef}, ${sampleSize})`;
+  }
+
+  buildQuantileAggregation(measure: MeasureConfig, quantiles: number[]): string {
+    const columnRef = BaseUtilities.buildColumnReference(
+      measure.tableName,
+      measure.columnName || measure.id,
+    );
+    const quantileList = quantiles.join(', ');
+
+    return `QUANTILE(${columnRef}, [${quantileList}])`;
+  }
+
+  buildMadAggregation(measure: MeasureConfig): string {
+    const columnRef = BaseUtilities.buildColumnReference(
+      measure.tableName,
+      measure.columnName || measure.id,
+    );
+
+    return `MAD(${columnRef})`;
+  }
+
+  buildModeAggregation(measure: MeasureConfig): string {
+    const columnRef = BaseUtilities.buildColumnReference(
+      measure.tableName,
+      measure.columnName || measure.id,
+    );
+
+    return `MODE(${columnRef})`;
+  }
+
+  buildProductAggregation(measure: MeasureConfig): string {
+    const columnRef = BaseUtilities.buildColumnReference(
+      measure.tableName,
+      measure.columnName || measure.id,
+    );
+
+    return `PRODUCT(${columnRef})`;
+  }
+}