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

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

@@ -0,0 +1,203 @@
+import {
+  EpmQueryBuilderOptions,
+  MeasureConfig,
+} from '@epm-query-builder/types/query-builder-types';
+import { BaseUtilities } from '@epm-query-builder/base/BaseUtilities';
+
+export class BaseAnalyticalFunctions {
+  protected options: EpmQueryBuilderOptions;
+
+  constructor(options: EpmQueryBuilderOptions) {
+    this.options = options;
+  }
+
+  buildWindowFunction(measure: MeasureConfig, windowSpec?: string): string {
+    const baseAggregation = this.buildBasicAggregation(measure);
+    const partitionBy = this.extractPartitionColumns();
+    const orderBy = this.extractOrderColumns();
+
+    let windowClause = 'OVER (';
+
+    if (partitionBy.length > 0) {
+      windowClause += `PARTITION BY ${partitionBy.join(', ')} `;
+    }
+
+    if (orderBy.length > 0) {
+      windowClause += `ORDER BY ${orderBy.join(', ')} `;
+    }
+
+    if (windowSpec) {
+      windowClause += windowSpec;
+    }
+
+    windowClause += ')';
+
+    return `${baseAggregation} ${windowClause}`;
+  }
+
+  buildRankingFunction(
+    measure: MeasureConfig,
+    rankType: 'ROW_NUMBER' | 'RANK' | 'DENSE_RANK' | 'PERCENT_RANK' = 'ROW_NUMBER',
+  ): string {
+    const orderBy = this.extractOrderColumns();
+    const partitionBy = this.extractPartitionColumns();
+
+    let windowClause = 'OVER (';
+
+    if (partitionBy.length > 0) {
+      windowClause += `PARTITION BY ${partitionBy.join(', ')} `;
+    }
+
+    if (orderBy.length > 0) {
+      windowClause += `ORDER BY ${orderBy.join(', ')}`;
+    }
+
+    windowClause += ')';
+
+    return `${rankType}() ${windowClause}`;
+  }
+
+  buildLagLeadFunction(
+    measure: MeasureConfig,
+    functionType: 'LAG' | 'LEAD',
+    offset = 1,
+    defaultValue?: string,
+  ): string {
+    const columnRef = BaseUtilities.buildColumnReference(
+      measure.tableName,
+      measure.columnName || measure.id,
+    );
+    const partitionBy = this.extractPartitionColumns();
+    const orderBy = this.extractOrderColumns();
+
+    let windowClause = 'OVER (';
+
+    if (partitionBy.length > 0) {
+      windowClause += `PARTITION BY ${partitionBy.join(', ')} `;
+    }
+
+    if (orderBy.length > 0) {
+      windowClause += `ORDER BY ${orderBy.join(', ')}`;
+    }
+
+    windowClause += ')';
+
+    const params = [columnRef, offset.toString()];
+    if (defaultValue !== undefined) {
+      params.push(defaultValue);
+    }
+
+    return `${functionType}(${params.join(', ')}) ${windowClause}`;
+  }
+
+  buildPercentileFunction(measure: MeasureConfig, percentile: number, continuous = true): string {
+    const columnRef = BaseUtilities.buildColumnReference(
+      measure.tableName,
+      measure.columnName || measure.id,
+    );
+    const functionName = continuous ? 'PERCENTILE_CONT' : 'PERCENTILE_DISC';
+
+    return `${functionName}(${percentile}) WITHIN GROUP (ORDER BY ${columnRef})`;
+  }
+
+  buildNtileFunction(measure: MeasureConfig, buckets: number): string {
+    const partitionBy = this.extractPartitionColumns();
+    const orderBy = this.extractOrderColumns();
+
+    let windowClause = 'OVER (';
+
+    if (partitionBy.length > 0) {
+      windowClause += `PARTITION BY ${partitionBy.join(', ')} `;
+    }
+
+    if (orderBy.length > 0) {
+      windowClause += `ORDER BY ${orderBy.join(', ')}`;
+    }
+
+    windowClause += ')';
+
+    return `NTILE(${buckets}) ${windowClause}`;
+  }
+
+  buildMovingAggregation(
+    measure: MeasureConfig,
+    aggregationType: string,
+    windowSize: number,
+  ): string {
+    const columnRef = BaseUtilities.buildColumnReference(
+      measure.tableName,
+      measure.columnName || measure.id,
+    );
+    const partitionBy = this.extractPartitionColumns();
+    const orderBy = this.extractOrderColumns();
+
+    let windowClause = 'OVER (';
+
+    if (partitionBy.length > 0) {
+      windowClause += `PARTITION BY ${partitionBy.join(', ')} `;
+    }
+
+    if (orderBy.length > 0) {
+      windowClause += `ORDER BY ${orderBy.join(', ')} `;
+    }
+
+    windowClause += `ROWS ${windowSize} PRECEDING)`;
+
+    return `${aggregationType.toUpperCase()}(${columnRef}) ${windowClause}`;
+  }
+
+  buildCumulativeAggregation(measure: MeasureConfig, aggregationType: string): string {
+    const columnRef = BaseUtilities.buildColumnReference(
+      measure.tableName,
+      measure.columnName || measure.id,
+    );
+    const partitionBy = this.extractPartitionColumns();
+    const orderBy = this.extractOrderColumns();
+
+    let windowClause = 'OVER (';
+
+    if (partitionBy.length > 0) {
+      windowClause += `PARTITION BY ${partitionBy.join(', ')} `;
+    }
+
+    if (orderBy.length > 0) {
+      windowClause += `ORDER BY ${orderBy.join(', ')} `;
+    }
+
+    windowClause += 'ROWS UNBOUNDED PRECEDING)';
+
+    return `${aggregationType.toUpperCase()}(${columnRef}) ${windowClause}`;
+  }
+
+  protected buildBasicAggregation(measure: MeasureConfig): string {
+    const columnRef = BaseUtilities.buildColumnReference(
+      measure.tableName,
+      measure.columnName || measure.id,
+    );
+    const aggregationType = measure.aggregationType || 'SUM';
+
+    return `${aggregationType.toUpperCase()}(${columnRef})`;
+  }
+
+  protected extractPartitionColumns(): string[] {
+    const rows = this.options.rows || [];
+    return rows.map((row) =>
+      BaseUtilities.buildColumnReference(row.tableName, row.columnName || row.id),
+    );
+  }
+
+  protected extractOrderColumns(): string[] {
+    if (!this.options.orderBy?.length) {
+      return [];
+    }
+
+    return this.options.orderBy.map((order) => {
+      const direction = order.type === 'DESC' ? 'DESC' : 'ASC';
+      const column = BaseUtilities.buildColumnReference(
+        order.tableName,
+        order.columnName || order.id,
+      );
+      return `${column} ${direction}`;
+    });
+  }
+}

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

@@ -0,0 +1,458 @@
+import {
+  EpmQueryBuilderOptions,
+  FilterConfig,
+  RankingConfig,
+} from '@epm-query-builder/types/query-builder-types';
+import { BaseUtilities } from '@epm-query-builder/base/BaseUtilities';
+import { SharedFilterBuilder } from '@epm-query-builder/base/SharedFilterBuilder';
+import { mapAggregationType as mapAgg } from '@epm-query-builder/constants/Aggregations';
+
+export abstract class BaseCTEGenerator {
+  protected options: EpmQueryBuilderOptions;
+
+  constructor(options: EpmQueryBuilderOptions) {
+    this.options = options;
+  }
+
+  protected generateCTE(name: string, query: string): string {
+    return BaseUtilities.buildCTETemplate(name, query);
+  }
+
+  protected buildFilterCTE(filter: FilterConfig, counter: number): string {
+    const variableName = `filter_${counter}`;
+    const specificCTE = this.buildSpecificFilterCTE(filter, variableName);
+
+    if (!specificCTE) return '';
+
+    return this.generateCTE(variableName, specificCTE);
+  }
+
+  protected buildBasicFilterCTE(filter: FilterConfig, _variableName?: string): string {
+    void _variableName;
+    if (!filter.columnNames?.length || !filter.tableNames?.length) {
+      return '';
+    }
+
+    const column = filter.columnNames[0];
+    const tableName = filter.tableNames[0];
+    const condition = SharedFilterBuilder.buildFilterCondition(filter);
+
+    if (!condition) return '';
+
+    return BaseUtilities.buildDistinctSelect([column], tableName, condition);
+  }
+
+  protected buildTupleFilterCTE(filter: FilterConfig, _variableName: string): string {
+    void _variableName;
+    if (!filter.columnNames?.length || filter.columnNames.length < 2) {
+      return this.buildBasicFilterCTE(filter);
+    }
+
+    const tableName = filter.tableNames?.[0] || '';
+    const columns = filter.columnNames;
+
+    if (!filter.valuesFilter?.length) return '';
+
+    const tupleConditions = filter.valuesFilter
+      .map((vf) => {
+        const ids = Array.isArray(vf.id) ? vf.id : [vf.id];
+        if (ids.length !== columns.length) return null;
+
+        const columnValuePairs = columns
+          .map((col, idx) => `${col} = ${BaseUtilities.formatValue(ids[idx].toString())}`)
+          .join(' AND ');
+
+        return `(${columnValuePairs})`;
+      })
+      .filter((condition): condition is string => Boolean(condition));
+
+    if (!tupleConditions.length) return '';
+
+    const tupleClause = BaseUtilities.combineConditions(tupleConditions, 'OR');
+    const isExclude = filter.valuesFilterApplicationType?.toUpperCase() === 'EXCLUDE';
+    const finalCondition = isExclude ? `NOT (${tupleClause})` : `(${tupleClause})`;
+
+    return BaseUtilities.buildDistinctSelect(columns, tableName, finalCondition);
+  }
+
+  protected buildComplexFilterCTE(filter: FilterConfig, variableName: string): string {
+    const filterType = filter.filterType?.toUpperCase();
+
+    if (filterType === 'TUPLE') {
+      return this.buildTupleFilterCTE(filter, variableName);
+    }
+
+    const condition = SharedFilterBuilder.buildFilterCondition(filter);
+    if (!condition) return '';
+
+    const column = filter.columnNames?.[0];
+    const tableName = filter.tableNames?.[0] || '';
+    if (!column) return '';
+    return BaseUtilities.buildDistinctSelect([column], tableName, condition);
+  }
+
+  generateFilterCTEs(): string {
+    if (!this.options.superFilters?.children) {
+      return '';
+    }
+
+    const filterCTEs: string[] = [];
+    let variableCounter = 1;
+
+    this.options.superFilters.children.forEach((child) => {
+      const filter = child.filters;
+      if (!filter) return;
+
+      if (this.isComplexFilter(filter)) {
+        const cte = this.buildFilterCTE(filter, variableCounter++);
+        if (cte) {
+          filterCTEs.push(cte);
+        }
+      }
+    });
+
+    return filterCTEs.length > 0 ? `WITH ${filterCTEs.join(',\n')}` : '';
+  }
+
+  protected buildRankingFilterCTE(filter: FilterConfig, _variableName: string): string {
+    void _variableName;
+    const rankingConfigs =
+      filter.rankingFilter || (filter.rankingConfig ? [filter.rankingConfig] : []);
+
+    if (!rankingConfigs.length || !filter.columnNames?.length) {
+      return '';
+    }
+
+    const column = filter.columnNames[0];
+    const tableName = filter.tableNames?.[0] || '';
+
+    if (rankingConfigs.length === 1) {
+      return this.buildSingleRankingCTE(filter, rankingConfigs[0], column, tableName);
+    }
+
+    const cteQueries = rankingConfigs
+      .map((rankingConfig) => this.buildSingleRankingCTE(filter, rankingConfig, column, tableName))
+      .filter((query) => query);
+
+    if (!cteQueries.length) return '';
+
+    const operator = filter.logicalOperator?.toUpperCase() === 'OR' ? 'UNION' : 'INTERSECT';
+    return cteQueries.join(` ${operator} `);
+  }
+
+  private buildSingleRankingCTE(
+    filter: FilterConfig,
+    rankingConfig: RankingConfig,
+    column: string,
+    tableName: string,
+  ): string {
+    const rankByColumnId =
+      rankingConfig.rankByColumnId ||
+      `${rankingConfig.rankByTableName || ''}[${rankingConfig.rankByColumnName || column}]`;
+    const actualColumnId = BaseUtilities.extractColumnIdFromHierarchy(rankByColumnId);
+    const rankColumn = actualColumnId;
+    const rankTable = rankingConfig.rankByTableName || tableName;
+    const aggregationType = this.mapAggregationType(rankingConfig.rankByAggregationType || 'SUM');
+
+    const topNValue = this.calculateTopNValue(
+      rankingConfig.value,
+      filter.distinctRowsCount || 1000000,
+      rankingConfig.isPercentage || false,
+    );
+
+    const rankByRef = rankTable ? `"${rankTable}"."${rankColumn}"` : `"${rankColumn}"`;
+
+    if (rankingConfig.type === 'BOTH') {
+      const topValue = Math.ceil(topNValue / 2);
+      const bottomValue = Math.floor(topNValue / 2);
+
+      const topQuery = this.buildRankingSelectQuery(
+        column,
+        tableName,
+        rankByRef,
+        aggregationType,
+        'DESC',
+        topValue,
+      );
+
+      const bottomQuery = this.buildRankingSelectQuery(
+        column,
+        tableName,
+        rankByRef,
+        aggregationType,
+        'ASC',
+        bottomValue,
+      );
+
+      return `(${topQuery}) UNION ALL (${bottomQuery})`;
+    }
+
+    const orderDirection = rankingConfig.type === 'TOP' ? 'DESC' : 'ASC';
+
+    return this.buildRankingSelectQuery(
+      column,
+      tableName,
+      rankByRef,
+      aggregationType,
+      orderDirection,
+      topNValue,
+      rankingConfig.isPercentage,
+    );
+  }
+
+  private buildRankingSelectQuery(
+    column: string,
+    tableName: string,
+    rankByRef: string,
+    aggregationType: string,
+    orderDirection: string,
+    topNValue: number,
+    isPercentage?: boolean,
+  ): string {
+    if (isPercentage) {
+      const percentileValue = topNValue / 100;
+      const condition = `PERCENT_RANK() OVER (ORDER BY ${aggregationType}(${rankByRef}) ${orderDirection}) <= ${percentileValue}`;
+      return BaseUtilities.buildDistinctSelect([`"${column}"`], `"${tableName}"`, condition);
+    } else {
+      const orderByClause = `${aggregationType}(${rankByRef}) ${orderDirection} LIMIT ${topNValue}`;
+      return BaseUtilities.buildDistinctSelect(
+        [`"${column}"`],
+        `"${tableName}"`,
+        undefined,
+        orderByClause,
+      );
+    }
+  }
+
+  private mapAggregationType(aggregationType: string): string {
+    return mapAgg(aggregationType);
+  }
+
+  protected buildSearchFilterCTE(filter: FilterConfig, _variableName: string): string {
+    void _variableName;
+    if (!BaseUtilities.validateRequiredFields(filter, ['columnNames', 'searchConditions'])) {
+      return '';
+    }
+
+    const column = filter.columnNames![0];
+    const tableName = filter.tableNames?.[0] || '';
+
+    const conditions = filter.searchConditions!.map((condition) => {
+      const canonical = (condition.operator || '')
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '_')
+        .replace(/^_+|_+$/g, '');
+      const rawValue = String(condition.value ?? '');
+      const escapedValue = rawValue.replace(/'/g, "''");
+
+      switch (canonical) {
+        case 'contains':
+          return `LOWER(${column}) LIKE LOWER('%${escapedValue}%')`;
+        case 'does_not_contain':
+        case 'not_contains':
+        case 'not_contain':
+          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_start_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_end_with':
+          return `LOWER(${column}) NOT LIKE LOWER('%${escapedValue}')`;
+        case 'equals':
+        case 'is_equal_to':
+        case 'is':
+          return `${column} = ${BaseUtilities.formatValue(rawValue)}`;
+        case 'not_equals':
+        case 'is_not_equal_to':
+        case 'is_not':
+          return `${column} != ${BaseUtilities.formatValue(rawValue)}`;
+        case 'is_blank':
+        case 'blank':
+          return `${column} IS NULL`;
+        case 'is_not_blank':
+        case '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}%')`;
+      }
+    });
+
+    const whereCondition = BaseUtilities.combineConditions(conditions, 'AND');
+    return BaseUtilities.buildDistinctSelect([column], tableName, whereCondition);
+  }
+
+  protected buildBlankFilterCTE(filter: FilterConfig, _variableName: string): string {
+    void _variableName;
+    if (!BaseUtilities.validateRequiredFields(filter, ['columnNames', 'blankFilterConfig'])) {
+      return '';
+    }
+
+    const column = filter.columnNames![0];
+    const tableName = filter.tableNames?.[0] || '';
+    const blankConfig = filter.blankFilterConfig!;
+
+    let condition: string;
+    if (blankConfig.operator === 'IS_BLANK') {
+      if (blankConfig.treatEmptyStringAsBlank) {
+        condition = `(${column} IS NULL OR TRIM(${column}) = '')`;
+      } else {
+        condition = `${column} IS NULL`;
+      }
+    } else {
+      if (blankConfig.treatEmptyStringAsBlank) {
+        condition = `(${column} IS NOT NULL AND TRIM(${column}) != '')`;
+      } else {
+        condition = `${column} IS NOT NULL`;
+      }
+    }
+
+    return BaseUtilities.buildDistinctSelect([column], tableName, condition);
+  }
+
+  protected buildRelativePeriodFilterCTE(filter: FilterConfig, _variableName: string): string {
+    void _variableName;
+    if (!BaseUtilities.validateRequiredFields(filter, ['columnNames', 'relativePeriodFilter'])) {
+      return '';
+    }
+
+    const column = filter.columnNames![0];
+    const tableName = filter.tableNames?.[0] || '';
+    const relativePeriod = filter.relativePeriodFilter!;
+
+    const condition = this.buildRelativePeriodCondition(column, relativePeriod);
+    return BaseUtilities.buildDistinctSelect([column], tableName, condition);
+  }
+
+  protected buildDateHierarchyFilterCTE(filter: FilterConfig, _variableName: string): string {
+    void _variableName;
+    if (!BaseUtilities.validateRequiredFields(filter, ['columnNames', 'dateHierarchyConfig'])) {
+      return '';
+    }
+
+    const column = filter.columnNames![0];
+    const tableName = filter.tableNames?.[0] || '';
+    const hierarchyConfig = filter.dateHierarchyConfig!;
+
+    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;
+      default:
+        hierarchyFunction = column;
+    }
+
+    const selectColumn = `${hierarchyFunction} AS ${column}_${hierarchyConfig.level.toLowerCase()}`;
+    return BaseUtilities.buildDistinctSelect([selectColumn], tableName);
+  }
+
+  protected buildFieldParameterFilterCTE(filter: FilterConfig, _variableName: string): string {
+    void _variableName;
+    if (!filter.fieldParameterMapping) {
+      return '';
+    }
+
+    const mapping = filter.fieldParameterMapping;
+    const tableName = mapping.targetTable;
+
+    if (!tableName || !mapping.targetField) return '';
+
+    return BaseUtilities.buildDistinctSelect([mapping.targetField], tableName);
+  }
+
+  protected 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}`;
+    }
+  }
+
+  private calculateTopNValue(value: number, totalCount: number, isPercentage: boolean): number {
+    if (totalCount === 0 || !isPercentage) {
+      return value;
+    }
+    return Math.floor((value * totalCount) / 100);
+  }
+
+  protected isComplexFilter(filter: FilterConfig): boolean {
+    return Boolean(
+      filter.filterType === 'TUPLE' ||
+      filter.filterType === 'RANKING' ||
+      filter.filterType === 'SEARCH' ||
+      filter.filterType === 'BLANK' ||
+      filter.filterType === 'RELATIVE_PERIOD' ||
+      filter.filterType === 'DATE_HIERARCHY' ||
+      filter.filterType === 'FIELD_PARAMETER' ||
+      filter.isCrossHighlight ||
+      (filter.filterType === 'RANGE' && filter.rangeFilter && filter.rangeFilter.length > 1) ||
+      (filter.filterType === 'VALUES' && filter.valuesFilter && filter.valuesFilter.length > 10),
+    );
+  }
+
+  abstract buildSpecificFilterCTE(filter: FilterConfig, variableName: string): string;
+}