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

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

@@ -0,0 +1,105 @@
+import { EpmQueryBuilderOptions } from '@epm-query-builder/types/query-builder-types';
+import { BaseUtilities } from '@epm-query-builder/base/BaseUtilities';
+import { BaseSuperFilterBuilder } from '@epm-query-builder/base/BaseSuperFilterBuilder';
+import { QueryGenerationError } from '@epm-query-builder/errors/QueryBuilderErrors';
+
+// chooses count strategy based on presence of group by or measures
+export class BaseCountQueryBuilder {
+  constructor(protected options: EpmQueryBuilderOptions) {}
+
+  // branches to grouped count when aggregation is involved
+  generateCountQuery(mainQuery: string): string {
+    try {
+      if (this.hasGroupBy() || BaseUtilities.hasMeasuresInOptions(this.options)) {
+        return this.generateGroupedCountQuery(mainQuery);
+      }
+      return this.generateSimpleCountQuery();
+    } catch (error) {
+      throw new QueryGenerationError(`Failed to generate count query: ${error}`, {
+        hasGroupBy: this.hasGroupBy(),
+        hasMeasures: BaseUtilities.hasMeasuresInOptions(this.options),
+      });
+    }
+  }
+
+  // counts distinct dims when dimensions exist, else total rows
+  private generateSimpleCountQuery(): string {
+    const dimensions = BaseUtilities.extractDimensionsFromOptions(this.options);
+    const fromClause = this.buildFromClause();
+    const whereClause = this.buildWhereClause();
+
+    if (dimensions.length === 0) {
+      return `
+                SELECT COUNT(*) as total_count
+                FROM ${fromClause}
+                ${whereClause}
+            `.trim();
+    }
+
+    return `
+            SELECT COUNT(DISTINCT ${dimensions.join(', ')}) as distinct_count
+            FROM ${fromClause}
+            ${whereClause}
+        `.trim();
+  }
+
+  // wraps main query to count rows after aggregation
+  private generateGroupedCountQuery(mainQuery: string): string {
+    return `
+            SELECT COUNT(*) as total_count
+            FROM (
+                ${mainQuery}
+            ) as main_result
+        `.trim();
+  }
+
+  // beware: naive left join on id across tables; change keys if schema differs
+  protected buildFromClause(): string {
+    const tables = new Set<string>();
+
+    [
+      ...(this.options.rows || []),
+      ...(this.options.columns || []),
+      ...(this.options.values || []),
+    ].forEach((item) => {
+      if (item.tableName) {
+        tables.add(item.tableName);
+      }
+    });
+
+    if (tables.size === 0) {
+      throw new QueryGenerationError('No tables found for count query');
+    }
+
+    if (tables.size === 1) {
+      return Array.from(tables)[0];
+    }
+
+    const tableArray = Array.from(tables);
+    const baseTable = tableArray[0];
+    let fromClause = baseTable;
+
+    for (let i = 1; i < tableArray.length; i++) {
+      fromClause += ` LEFT JOIN ${tableArray[i]} ON ${baseTable}.id = ${tableArray[i]}.id`;
+    }
+
+    return fromClause;
+  }
+
+  protected buildWhereClause(): string {
+    if (!this.options.superFilters) return '';
+    const superFilterBuilder = new BaseSuperFilterBuilder(this.options);
+    const where = superFilterBuilder.buildWhereClause();
+    return where ? `WHERE ${where}` : '';
+  }
+
+  protected hasGroupBy(): boolean {
+    const hasRows = (this.options.rows?.length || 0) > 0;
+    const hasColumns = (this.options.columns?.length || 0) > 0;
+    return hasRows || hasColumns;
+  }
+
+  protected hasMeasures(): boolean {
+    return (this.options.values?.length || 0) > 0;
+  }
+}

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

@@ -0,0 +1,87 @@
+import {
+  EpmQueryBuilderOptions,
+  MeasureConfig,
+} from '@epm-query-builder/types/query-builder-types';
+import { BaseUtilities } from '@epm-query-builder/base/BaseUtilities';
+
+export abstract class BaseMeasureBuilder {
+  protected options: EpmQueryBuilderOptions;
+
+  constructor(options: EpmQueryBuilderOptions) {
+    this.options = options;
+  }
+
+  protected buildStandardAggregation(measure: MeasureConfig): string {
+    // If no aggregation type, use the measure ID directly without prefix
+    const hasAggregation = measure.aggregationType && measure.aggregationType.trim() !== '';
+    if (!hasAggregation) {
+      return measure.id;
+    }
+
+    const original = (measure.aggregationType || 'SUM').toUpperCase();
+    const aliasPrefix =
+      original === 'FIRST'
+        ? 'FIRST'
+        : original === 'LAST'
+          ? 'LAST'
+          : BaseUtilities.mapAggregationType(original);
+    return `${aliasPrefix}__${measure.id}`;
+  }
+
+  protected buildCalculatedMeasure(measure: MeasureConfig): string {
+    return `"${measure.id}"`;
+  }
+
+  protected buildConditionalMeasure(measure: MeasureConfig): string {
+    // If no aggregation type, use the measure ID directly without prefix
+    const hasAggregation = measure.aggregationType && measure.aggregationType.trim() !== '';
+    if (!hasAggregation) {
+      return measure.id;
+    }
+
+    const original = (measure.aggregationType || 'SUM').toUpperCase();
+    const aliasPrefix =
+      original === 'FIRST'
+        ? 'FIRST'
+        : original === 'LAST'
+          ? 'LAST'
+          : BaseUtilities.mapAggregationType(original);
+    return `${aliasPrefix}__${measure.id}`;
+  }
+
+  protected isMeasureType(measure: MeasureConfig): boolean {
+    return measure.type?.toLowerCase() === 'measure';
+  }
+
+  protected formatMeasureAlias(measure: MeasureConfig): string {
+    if (this.isMeasureType(measure)) {
+      return `${measure.tableName}[${measure.columnName}]`;
+    }
+    // If no aggregation type, use column name without prefix
+    const hasAggregation = measure.aggregationType && measure.aggregationType.trim() !== '';
+    if (!hasAggregation) {
+      return `${measure.tableName}[${measure.columnName}]`;
+    }
+    return `${measure.aggregationType}__${measure.tableName}[${measure.columnName}]`;
+  }
+
+  protected getMeasures(): MeasureConfig[] {
+    return (this.options.values || []) as MeasureConfig[];
+  }
+
+  protected buildMeasureExpressions(): string[] {
+    const measures = this.getMeasures();
+
+    return measures.map((measure) => {
+      if (this.isMeasureType(measure)) {
+        return this.buildCalculatedMeasure(measure);
+      }
+      return this.buildStandardAggregation(measure);
+    });
+  }
+
+  protected buildMeasureSelectClause(): string {
+    const expressions = this.buildMeasureExpressions();
+    return expressions.join(', ');
+  }
+}

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

@@ -0,0 +1,195 @@
+import {
+  EpmQueryBuilderOptions,
+  OrderByConfig,
+  RowColumnConfig,
+} from '@epm-query-builder/types/query-builder-types';
+import { BaseUtilities } from '@epm-query-builder/base/BaseUtilities';
+
+// orchestrates order by strategy: rollup, custom, or defaults
+export abstract class BaseOrderBuilder {
+  protected options: EpmQueryBuilderOptions;
+
+  constructor(options: EpmQueryBuilderOptions) {
+    this.options = options;
+  }
+
+  buildOrderByClause(): string {
+    const orderByClauses = this.buildOrderByClauses();
+
+    if (orderByClauses.length === 0) {
+      return '';
+    }
+
+    return `ORDER BY ${orderByClauses.join(', ')}`;
+  }
+
+  // combines rollup, custom, and default clauses
+  protected buildOrderByClauses(): string[] {
+    const clauses: string[] = [];
+
+    if (this.hasRollupOrdering()) {
+      clauses.push(...this.buildRollupOrderClauses());
+    }
+
+    if (this.options.orderBy?.length) {
+      clauses.push(...this.buildCustomOrderClauses());
+    } else {
+      clauses.push(...this.buildDefaultOrderClauses());
+    }
+
+    return clauses;
+  }
+
+  // uses explicit orderBy configs
+  protected buildCustomOrderClauses(): string[] {
+    if (!this.options.orderBy?.length) {
+      return [];
+    }
+
+    return this.options.orderBy.map((orderBy) => {
+      const column = this.resolveOrderByColumn(orderBy);
+      return `${column} ${orderBy.type}`;
+    });
+  }
+
+  // falls back to ordering by requested dimensions
+  protected buildDefaultOrderClauses(): string[] {
+    const clauses: string[] = [];
+
+    if (this.options.rows?.length) {
+      this.options.rows.forEach((row) => {
+        const column = this.formatOrderByColumn(row);
+        clauses.push(`${column} ASC`);
+      });
+    }
+
+    if (this.options.columns?.length) {
+      this.options.columns.forEach((col) => {
+        const column = this.formatOrderByColumn(col);
+        clauses.push(`${column} ASC`);
+      });
+    }
+
+    return clauses;
+  }
+
+  // adds rollup-based ordering when rollup is generated
+  protected buildRollupOrderClauses(): string[] {
+    const clauses: string[] = [];
+
+    if (this.options.rows?.length && !this.options.skipRollup) {
+      clauses.push('"IsRowGrandTotal" DESC');
+    }
+
+    if (this.options.columns?.length && !this.options.skipRollup) {
+      clauses.push('"IsColumnGrandTotal" DESC');
+    }
+
+    return clauses;
+  }
+
+  protected resolveOrderByColumn(orderBy: OrderByConfig): string {
+    if (orderBy.isColumnPresentInOutput) {
+      if (orderBy.aggregationType) {
+        return `"${orderBy.aggregationType}__${orderBy.tableName}[${orderBy.columnName}]"`;
+      }
+      return `"${orderBy.tableName}[${orderBy.columnName}]"`;
+    }
+
+    const tableName = orderBy.tableName || '';
+    return `${tableName}.${orderBy.columnName}`;
+  }
+
+  protected formatOrderByColumn(config: RowColumnConfig): string {
+    if (config.orderByRef) {
+      const tableName = config.tableName || '';
+      return `${tableName}.${config.orderByRef}`;
+    }
+
+    const tableName = config.tableName || '';
+    return `${tableName}.${config.columnName}`;
+  }
+
+  protected handleColumnPresentInOutput(orderBy: OrderByConfig): boolean {
+    return Boolean(orderBy.isColumnPresentInOutput);
+  }
+
+  // ensures correct direction and reference when column is already in output
+  protected buildOrderByWithOutput(orderBy: OrderByConfig): string {
+    if (!this.handleColumnPresentInOutput(orderBy)) {
+      return '';
+    }
+
+    if (orderBy.aggregationType) {
+      const columnRef = `"${orderBy.aggregationType}__${orderBy.tableName}[${orderBy.columnName}]"`;
+      return `${columnRef} ${this.mapSortDirection(orderBy.type)}`;
+    }
+
+    const tableName = orderBy.tableName || '';
+    const columnRef = `${tableName}.${orderBy.columnName}`;
+    const direction = this.mapSortDirection(orderBy.type);
+
+    return `${columnRef} ${direction}`;
+  }
+
+  protected applyExpansionConfig(config: RowColumnConfig): string[] {
+    const expansions: string[] = [];
+
+    if (!config.expansionConfig) {
+      return expansions;
+    }
+
+    const expansion = config.expansionConfig;
+    const baseColumn = `${config.tableName}.${config.columnName}`;
+
+    switch (expansion.expansionType?.toLowerCase()) {
+      case 'hierarchy':
+        if (expansion.hierarchies?.length) {
+          expansion.hierarchies.forEach((hierarchy) => {
+            expansions.push(`${baseColumn}_${hierarchy}`);
+          });
+        }
+        break;
+      case 'date_parts':
+        if (expansion.items?.length) {
+          expansion.items.forEach((part) => {
+            expansions.push(
+              `EXTRACT(${part.toUpperCase()} FROM ${baseColumn}) AS ${config.columnName}_${part}`,
+            );
+          });
+        }
+        break;
+      case 'range':
+        if (expansion.start && expansion.end && expansion.step) {
+          const steps = Math.ceil(
+            (Number(expansion.end) - Number(expansion.start)) / expansion.step,
+          );
+          for (let i = 0; i <= steps; i++) {
+            const value = Number(expansion.start) + i * expansion.step;
+            expansions.push(`${value} AS ${config.columnName}_${i}`);
+          }
+        }
+        break;
+      default:
+        break;
+    }
+
+    return expansions;
+  }
+
+  protected mapSortDirection(direction?: string): 'ASC' | 'DESC' {
+    return direction?.toUpperCase() === 'DESC' ? 'DESC' : 'ASC';
+  }
+
+  protected hasRollupOrdering(): boolean {
+    return BaseUtilities.shouldGenerateRollupForOptions(this.options);
+  }
+
+  protected hasDimensions(): boolean {
+    return BaseUtilities.hasDimensionsInOptions(this.options);
+  }
+
+  protected hasCustomOrderBy(): boolean {
+    return Boolean(this.options.orderBy?.length);
+  }
+}

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

@@ -0,0 +1,93 @@
+import { EpmQueryBuilderOptions } from '@epm-query-builder/types/query-builder-types';
+
+// pagination helpers: build limit/offset fragments and metadata
+export abstract class BasePaginationBuilder {
+  protected options: EpmQueryBuilderOptions;
+
+  constructor(options: EpmQueryBuilderOptions) {
+    this.options = options;
+  }
+
+  // builds dialect-agnostic limit clause
+  protected buildLimitClause(): string {
+    const pagination = this.options.pagination;
+    const limit = pagination?.limit || pagination?.take;
+    if (!pagination || !limit || limit <= 0) {
+      return '';
+    }
+
+    return `LIMIT ${limit}`;
+  }
+
+  // builds offset clause when offset provided
+  protected buildOffsetClause(offset = 0): string {
+    if (offset <= 0) {
+      return '';
+    }
+
+    return `OFFSET ${offset}`;
+  }
+
+  // composes limit and offset when both exist
+  protected buildLimitOffsetClause(offset = 0): string {
+    const limitClause = this.buildLimitClause();
+    const offsetClause = this.buildOffsetClause(offset);
+
+    const clauses = [limitClause, offsetClause].filter((clause) => clause);
+    return clauses.join(' ');
+  }
+
+  // derives count selection from a base query for pagination metadata
+  protected buildCountQuery(baseQuery: string): string {
+    const fromIndex = baseQuery.toLowerCase().indexOf('from');
+    if (fromIndex === -1) {
+      return '';
+    }
+
+    const fromClause = baseQuery.substring(fromIndex);
+    const orderByIndex = fromClause.toLowerCase().lastIndexOf('order by');
+    const limitIndex = fromClause.toLowerCase().lastIndexOf('limit');
+
+    let cleanFromClause = fromClause;
+    if (orderByIndex !== -1) {
+      cleanFromClause = fromClause.substring(0, orderByIndex).trim();
+    }
+    if (limitIndex !== -1 && (orderByIndex === -1 || limitIndex < orderByIndex)) {
+      cleanFromClause = fromClause.substring(0, limitIndex).trim();
+    }
+
+    return `SELECT COUNT(*) as total ${cleanFromClause}`;
+  }
+
+  protected hasPagination(): boolean {
+    return Boolean(
+      this.options.pagination && (this.options.pagination.limit || this.options.pagination.take),
+    );
+  }
+
+  protected getPaginationLimit(): number {
+    return this.options.pagination?.limit || this.options.pagination?.take || 100;
+  }
+
+  // computes basic pagination metadata for consumers
+  protected buildPaginationMetadata(
+    totalCount: number,
+    limit: number,
+    offset = 0,
+  ): Record<string, unknown> {
+    const currentPage = Math.floor(offset / limit) + 1;
+    const totalPages = Math.ceil(totalCount / limit);
+    const hasNextPage = currentPage < totalPages;
+    const hasPreviousPage = currentPage > 1;
+
+    return {
+      totalCount,
+      limit,
+      offset,
+      currentPage,
+      totalPages,
+      hasNextPage,
+      hasPreviousPage,
+    };
+  }
+}

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

@@ -0,0 +1,51 @@
+// base class: common helpers for dialect query builders
+import {
+  EpmQueryBuilderOptions,
+  OrderByConfig,
+} from '@epm-query-builder/types/query-builder-types';
+import { BaseUtilities } from '@epm-query-builder/base/BaseUtilities';
+import { BaseSqlBuilder } from '@epm-query-builder/base/BaseSqlBuilder';
+
+export abstract class BaseQueryBuilder extends BaseSqlBuilder {
+  constructor(options: EpmQueryBuilderOptions) {
+    super(options);
+  }
+
+  abstract generateQuery(): string;
+
+  protected shouldGenerateAnalyticalQuery(): boolean {
+    return BaseUtilities.shouldGenerateAnalyticalQueryForOptions(this.options);
+  }
+
+  protected shouldGenerateRollup(): boolean {
+    return BaseUtilities.shouldGenerateRollupForOptions(this.options);
+  }
+
+  protected hasComplexFilters(): boolean {
+    return Boolean(this.options.superFilters?.children?.length);
+  }
+
+  protected buildBasicGroupByClause(): string {
+    return BaseUtilities.buildBasicGroupByClauseForOptions(this.options);
+  }
+
+  protected mapSortDirection(direction?: string): 'ASC' | 'DESC' {
+    return direction?.toUpperCase() === 'DESC' ? 'DESC' : 'ASC';
+  }
+
+  protected resolveOrderByColumn(orderBy: OrderByConfig): string {
+    if (orderBy.isColumnPresentInOutput) {
+      if (orderBy.aggregationType) {
+        return `"${orderBy.aggregationType}__${orderBy.tableName}[${orderBy.columnName}]"`;
+      }
+      return `"${orderBy.tableName}[${orderBy.columnName}]"`;
+    }
+
+    const tableName = orderBy.tableName || '';
+    return `${tableName}.${orderBy.columnName}`;
+  }
+
+  protected buildJoinClause(joinType: string, table: string, condition: string): string {
+    return `${joinType} ${table} ON ${condition}`;
+  }
+}

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

@@ -0,0 +1,149 @@
+import { EpmQueryBuilderOptions } from '@epm-query-builder/types/query-builder-types';
+import { BaseUtilities } from '@epm-query-builder/base/BaseUtilities';
+
+// computes grouping sets and rollup indicators for rollup queries
+export abstract class BaseRollupBuilder {
+  protected options: EpmQueryBuilderOptions;
+
+  constructor(options: EpmQueryBuilderOptions) {
+    this.options = options;
+  }
+
+  protected shouldGenerateRollup(): boolean {
+    return BaseUtilities.shouldGenerateRollupForOptions(this.options);
+  }
+
+  protected hasDimensions(): boolean {
+    return BaseUtilities.hasDimensionsInOptions(this.options);
+  }
+
+  // extracts dimension references for rollup
+  protected getDimensions(): string[] {
+    const rowDimensions = BaseUtilities.buildDimensionReference(this.options.rows, this.options);
+    const columnDimensions = BaseUtilities.buildDimensionReference(
+      this.options.columns,
+      this.options,
+    );
+    return [...rowDimensions, ...columnDimensions];
+  }
+
+  // builds grouping sets for subtotal/grand total computation
+  // generates hierarchical rollup combinations for rows and columns separately
+  // avoiding cross-product combinations that create unwanted blank cells
+  protected buildGroupingSets(): string {
+    const rowDimensions = BaseUtilities.buildDimensionReference(this.options.rows, this.options);
+    const columnDimensions = BaseUtilities.buildDimensionReference(
+      this.options.columns,
+      this.options,
+    );
+
+    const allDimensions = [...rowDimensions, ...columnDimensions];
+    if (allDimensions.length === 0) {
+      return '';
+    }
+
+    const groupingSets: string[] = [];
+    const seenCombinations = new Set<string>();
+
+    const addGroupingSet = (dims: string[]) => {
+      if (dims.length === 0) {
+        if (!seenCombinations.has('()')) {
+          groupingSets.push('()');
+          seenCombinations.add('()');
+        }
+      } else {
+        const key = dims.join(',');
+        if (!seenCombinations.has(key)) {
+          groupingSets.push(`(${dims.join(', ')})`);
+          seenCombinations.add(key);
+        }
+      }
+    };
+
+    addGroupingSet(allDimensions);
+
+    for (let i = 0; i < rowDimensions.length; i++) {
+      addGroupingSet(rowDimensions.slice(0, i + 1));
+    }
+
+    for (let i = 0; i < columnDimensions.length; i++) {
+      addGroupingSet(columnDimensions.slice(0, i + 1));
+    }
+
+    const dimPrefix: string[] = [];
+    for (const rowDim of rowDimensions) {
+      dimPrefix.push(rowDim);
+      const colPrefix: string[] = [];
+      for (const colDim of columnDimensions) {
+        colPrefix.push(colDim);
+        const combined = [...dimPrefix, ...colPrefix];
+        addGroupingSet(combined);
+      }
+    }
+
+    if (rowDimensions.length > 0 || columnDimensions.length > 0) {
+      addGroupingSet([]);
+    }
+
+    return `GROUPING SETS (${groupingSets.join(', ')})`;
+  }
+
+  // emits boolean flags to identify totals in output rows
+  protected generateRollupIndicators(): string[] {
+    const indicators: string[] = [];
+    const rowCount = this.options.rows?.length || 0;
+    const columnCount = this.options.columns?.length || 0;
+
+    if (rowCount > 0) {
+      indicators.push(
+        'CASE WHEN GROUPING_ID() & 1 = 1 THEN true ELSE false END AS "IsRowGrandTotal"',
+      );
+
+      for (let i = 1; i < rowCount; i++) {
+        const mask = Math.pow(2, i);
+        indicators.push(
+          `CASE WHEN GROUPING_ID() & ${mask} = ${mask} THEN true ELSE false END AS "IsDM${i - 1}Total"`,
+        );
+      }
+    }
+
+    if (columnCount > 0) {
+      const columnMask = Math.pow(2, rowCount);
+      indicators.push(
+        `CASE WHEN GROUPING_ID() & ${columnMask} = ${columnMask} THEN true ELSE false END AS "IsColumnGrandTotal"`,
+      );
+
+      for (let i = 1; i < columnCount; i++) {
+        const mask = Math.pow(2, rowCount + i);
+        indicators.push(
+          `CASE WHEN GROUPING_ID() & ${mask} = ${mask} THEN true ELSE false END AS "IsDM${rowCount + i - 1}Total"`,
+        );
+      }
+    }
+
+    return indicators;
+  }
+
+  protected buildBasicGroupByClause(): string {
+    return BaseUtilities.buildBasicGroupByClauseForOptions(this.options);
+  }
+
+  // standard combinations generator used for grouping sets
+  protected generateCombinations<T>(array: T[], size: number): T[][] {
+    if (size === 0) return [[]];
+    if (size > array.length) return [];
+
+    const combinations: T[][] = [];
+
+    for (let i = 0; i <= array.length - size; i++) {
+      const head = array[i];
+      const tailCombinations = this.generateCombinations(array.slice(i + 1), size - 1);
+
+      for (const tail of tailCombinations) {
+        combinations.push([head, ...tail]);
+      }
+    }
+
+    return combinations;
+  }
+}