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

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

@@ -0,0 +1,131 @@
+import { BaseRollupBuilder } from '@epm-query-builder/base/BaseRollupBuilder';
+import { BaseUtilities } from '@epm-query-builder/base/BaseUtilities';
+
+export class DuckDbRollupBuilder extends BaseRollupBuilder {
+  buildGroupByClause(): string {
+    if (!this.shouldGenerateRollup()) {
+      return this.buildBasicGroupByClause();
+    }
+
+    const groupingSets = this.buildGroupingSets();
+    if (!groupingSets) {
+      return '';
+    }
+    return `GROUP BY ${groupingSets}`;
+  }
+
+  buildRollupSelects(): string[] {
+    if (!this.shouldGenerateRollup()) {
+      return [];
+    }
+
+    const selects: string[] = [];
+
+    selects.push(...this.buildRollupTotalIndicators());
+
+    return selects;
+  }
+
+  buildNullFilterConditions(): string[] {
+    if (!this.shouldGenerateRollup()) {
+      return [];
+    }
+
+    const dimensions = this.getDimensions();
+    if (dimensions.length === 0) {
+      return [];
+    }
+
+    return dimensions.map((dim) => `${dim} IS NOT NULL`);
+  }
+
+  private buildGroupingIndicators(): string[] {
+    const dimensions = this.getDimensions();
+    const indicators: string[] = [];
+    dimensions.forEach(() => {
+      // intentionally omitted raw GROUPING columns from the sql output, need to handle separately in the case of IB
+    });
+    return indicators;
+  }
+
+  private buildRollupTotalIndicators(): string[] {
+    const indicators: string[] = [];
+    const rowCount = this.options.rows?.length || 0;
+    const columnCount = this.options.columns?.length || 0;
+
+    if (rowCount > 0) {
+      const rowDimensions = this.getRowDimensions();
+
+      if (rowDimensions.length > 0) {
+        const groupingCondition = rowDimensions
+          .map((_, index) => `GROUPING(${rowDimensions[index]}) = 1`)
+          .join(' AND ');
+
+        indicators.push(
+          `CASE WHEN ${groupingCondition} THEN true ELSE false END AS "[IsRowGrandTotal]"`,
+        );
+
+        for (let i = 1; i < rowCount; i++) {
+          const partialGroupingCondition = rowDimensions
+            .slice(i)
+            .map((_, idx) => `GROUPING(${rowDimensions[i + idx]}) = 1`)
+            .join(' AND ');
+
+          const nonGroupingCondition = rowDimensions
+            .slice(0, i)
+            .map((_, idx) => `GROUPING(${rowDimensions[idx]}) = 0`)
+            .join(' AND ');
+
+          const dmCondition =
+            i === 1
+              ? `(${nonGroupingCondition} AND ${partialGroupingCondition}) OR (${groupingCondition})`
+              : `${nonGroupingCondition} AND ${partialGroupingCondition}`;
+
+          indicators.push(
+            `CASE WHEN ${dmCondition} THEN true ELSE false END AS "[IsDM${i - 1}Total]"`,
+          );
+        }
+      }
+    }
+
+    if (columnCount > 0) {
+      const columnDimensions = this.getColumnDimensions();
+
+      if (columnDimensions.length > 0) {
+        const groupingCondition = columnDimensions
+          .map((_, index) => `GROUPING(${columnDimensions[index]}) = 1`)
+          .join(' AND ');
+
+        indicators.push(
+          `CASE WHEN ${groupingCondition} THEN true ELSE false END AS "[IsColumnGrandTotal]"`,
+        );
+
+        for (let i = 1; i < columnCount; i++) {
+          const partialGroupingCondition = columnDimensions
+            .slice(i)
+            .map((_, idx) => `GROUPING(${columnDimensions[i + idx]}) = 1`)
+            .join(' AND ');
+
+          const nonGroupingCondition = columnDimensions
+            .slice(0, i)
+            .map((_, idx) => `GROUPING(${columnDimensions[idx]}) = 0`)
+            .join(' AND ');
+
+          indicators.push(
+            `CASE WHEN ${nonGroupingCondition} AND ${partialGroupingCondition} THEN true ELSE false END AS "[IsDM${rowCount + i - 1}Total]"`,
+          );
+        }
+      }
+    }
+
+    return indicators;
+  }
+
+  private getRowDimensions(): string[] {
+    return BaseUtilities.buildDimensionReference(this.options.rows, this.options);
+  }
+
+  private getColumnDimensions(): string[] {
+    return BaseUtilities.buildDimensionReference(this.options.columns, this.options);
+  }
+}

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

@@ -0,0 +1,370 @@
+import { BaseSuperFilterBuilder } from '@epm-query-builder/base/BaseSuperFilterBuilder';
+import { FilterConfig, EpmQueryBuilderOptions } from '@epm-query-builder/types/query-builder-types';
+import { BaseCTEGenerator } from '@epm-query-builder/base/BaseCTEGenerator';
+import { BaseUtilities } from '@epm-query-builder/base/BaseUtilities';
+import { SharedFilterBuilder } from '@epm-query-builder/base/SharedFilterBuilder';
+import { SOURCE_TYPES } from '@epm-query-builder/constants/Source';
+
+export class DuckDbSuperFilterBuilder extends BaseSuperFilterBuilder {
+  private cteGenerator: BaseCTEGenerator;
+
+  constructor(options: EpmQueryBuilderOptions) {
+    super(options);
+    this.cteGenerator = new (class extends BaseCTEGenerator {
+      buildSpecificFilterCTE(filter: FilterConfig, variableName: string): string {
+        if (filter.filterType?.toUpperCase() === 'RANKING') {
+          return '';
+        }
+        const source = BaseUtilities.getSource(this.options);
+        if (source === SOURCE_TYPES.BLEND) {
+          const fromIds = filter.columnIds || [];
+          const fromNames = filter.columnNames || [];
+          const resolvedNames: string[] = [];
+          const maxLen = Math.max(fromIds.length, fromNames.length);
+          for (let i = 0; i < Math.max(maxLen, 1); i += 1) {
+            const id = fromIds[i];
+            const name = fromNames[i];
+            if (id) {
+              resolvedNames.push(id);
+            } else if (name) {
+              resolvedNames.push(name);
+            }
+          }
+          const adjusted: FilterConfig = {
+            ...filter,
+            columnNames: resolvedNames.length ? resolvedNames : filter.columnNames,
+            columnIds: [],
+          };
+
+          const condition = SharedFilterBuilder.buildFilterCondition(adjusted);
+          if (!condition) return '';
+
+          const tableName = adjusted.tableNames?.[0] || '';
+          const useDot = BaseUtilities.shouldUseDotNotation(this.options);
+          const tableForRef =
+            tableName || BaseUtilities.getDefaultTableNameFromOptions(this.options);
+          const selectColumnName = adjusted.columnNames?.[0] || '';
+          const columnRef = useDot
+            ? BaseUtilities.buildColumnReference(tableForRef, selectColumnName)
+            : `"${selectColumnName}"`;
+
+          return BaseUtilities.buildDistinctSelect([columnRef], tableName, condition);
+        }
+        return this.buildComplexFilterCTE(filter, variableName);
+      }
+      protected isComplexFilter(filter: FilterConfig): boolean {
+        if (filter.filterType?.toUpperCase() === 'RANKING') {
+          return false;
+        }
+        return super.isComplexFilter(filter);
+      }
+    })(options);
+  }
+  buildWhereClause(): string {
+    if (!this.options.superFilters) {
+      return '';
+    }
+
+    return this.buildNestedFilterGroups(this.options.superFilters);
+  }
+
+  buildFilterCTE(): string {
+    const complex = this.hasComplexFilters() ? this.cteGenerator.generateFilterCTEs() : '';
+    const orGroup = this.buildOrGroupCTE();
+
+    if (!complex && !orGroup) return '';
+
+    const complexDefs = complex.replace(/^\s*WITH\s+/i, '');
+
+    if (complexDefs && !orGroup) return complexDefs;
+    if (!complexDefs && orGroup) return orGroup;
+
+    return `${complexDefs},\n${orGroup}`;
+  }
+
+  protected buildMeasureFilter(): string {
+    const measureFilters = this.extractMeasureFilters();
+    if (measureFilters.length === 0) {
+      return '';
+    }
+
+    const conditions = measureFilters.map((filter) => this.buildMeasureCondition(filter));
+    return BaseUtilities.combineConditions(
+      conditions.filter((c) => c),
+      'AND',
+    );
+  }
+
+  protected buildValuesFilter(filter: FilterConfig): string {
+    if (!filter.columnNames?.length || !filter.valuesFilter?.length) {
+      return '';
+    }
+
+    const source = BaseUtilities.getSource(this.options);
+    const columnFromIds = filter.columnIds?.[0];
+    const columnFromNames = filter.columnNames[0];
+    const resolvedForDb =
+      source === SOURCE_TYPES.BLEND
+        ? columnFromIds || columnFromNames
+        : BaseUtilities.extractColumnIdFromHierarchy(columnFromIds || columnFromNames);
+    const useDot = BaseUtilities.shouldUseDotNotation(this.options);
+    const columnReference = useDot
+      ? BaseUtilities.buildColumnReference(
+          filter.tableNames?.[0] || BaseUtilities.getDefaultTableNameFromOptions(this.options),
+          resolvedForDb,
+        )
+      : `"${resolvedForDb}"`;
+
+    const values = filter.valuesFilter
+      .flatMap((vf) => (Array.isArray(vf.id) ? vf.id : [vf.id]))
+      .filter((v) => v !== undefined);
+
+    if (values.length === 0) {
+      return '';
+    }
+
+    if (filter.isCrossHighlight === true) {
+      return SharedFilterBuilder.buildValuesFilter(this.adjustFilterForBlend(filter));
+    }
+
+    const operator =
+      filter.valuesFilterApplicationType?.toUpperCase() === 'INCLUDE' ? 'IN' : 'NOT IN';
+    const valueList = values.map((v) => BaseUtilities.formatValue(v.toString())).join(',');
+
+    return `${columnReference} ${operator} (${valueList})`;
+  }
+
+  private adjustFilterForBlend(filter: FilterConfig): FilterConfig {
+    const src = BaseUtilities.getSource(this.options);
+    if (src !== SOURCE_TYPES.BLEND) return filter;
+    const fromIds = filter.columnIds || [];
+    const fromNames = filter.columnNames || [];
+    const resolvedNames: string[] = [];
+    const maxLen = Math.max(fromIds.length, fromNames.length);
+    for (let i = 0; i < Math.max(maxLen, 1); i += 1) {
+      const id = fromIds[i];
+      const name = fromNames[i];
+      if (id) {
+        resolvedNames.push(id);
+      } else if (name) {
+        resolvedNames.push(name);
+      }
+    }
+    return {
+      ...filter,
+      columnNames: resolvedNames.length ? resolvedNames : filter.columnNames,
+      columnIds: [],
+    };
+  }
+
+  protected buildFilterCondition(filter: FilterConfig): string {
+    if (!filter) return '';
+    const type = filter.filterType?.toUpperCase();
+    if (type === 'MEASURE') return '';
+
+    const normalized = this.normalizeFilterColumns(filter);
+
+    if (type === 'VALUES') return this.buildValuesFilter(normalized);
+    if (type === 'RANGE') {
+      const hasAgg =
+        Array.isArray(normalized.aggregationType) && normalized.aggregationType.length > 0;
+      if (hasAgg) {
+        // if RANGE filter has aggregationType but only checks for blank/not blank,
+        // generate a WHERE clause on the base column (non-aggregated).
+        if (this.hasOnlyBlankRangeComparisons(normalized)) {
+          return this.buildBlankRangeWhere(normalized);
+        }
+        return '';
+      }
+    }
+    const adjusted = this.adjustFilterForBlend(normalized);
+    switch (type) {
+      case 'RANGE':
+        return SharedFilterBuilder.buildRangeFilter(adjusted);
+      case 'DATE':
+      case 'DATE_RANGE':
+        return SharedFilterBuilder.buildDateFilter(adjusted);
+      case 'RANKING':
+        return '';
+      case 'SEARCH':
+        return SharedFilterBuilder.buildSearchFilter(adjusted);
+      case 'BLANK':
+        return SharedFilterBuilder.buildBlankFilter(adjusted);
+      case 'TUPLE':
+        return SharedFilterBuilder.buildTupleFilter(adjusted);
+      case 'RELATIVE_PERIOD':
+        return SharedFilterBuilder.buildRelativePeriodFilter(adjusted);
+      case 'DATE_HIERARCHY':
+        return SharedFilterBuilder.buildDateHierarchyFilter(adjusted);
+      case 'FIELD_PARAMETER':
+        return SharedFilterBuilder.buildFieldParameterFilter(adjusted);
+      default:
+        return '';
+    }
+  }
+
+  private normalizeFilterColumns(filter: FilterConfig): FilterConfig {
+    const columnIds = filter.columnIds || [];
+    const source = BaseUtilities.getSource(this.options);
+    const normalizedColumnNames = columnIds.length
+      ? columnIds.map((id) => BaseUtilities.extractColumnIdFromHierarchy(id))
+      : filter.columnNames || [];
+
+    return {
+      ...filter,
+      columnNames: normalizedColumnNames,
+      columnIds: source === SOURCE_TYPES.BLEND ? filter.columnIds : [],
+    };
+  }
+
+  private isBlankOperator(op?: string): boolean {
+    if (!op) return false;
+    const canonical = op.toUpperCase().replace(/[^A-Z_]+/g, '_');
+    return canonical === 'IS_BLANK' || canonical === 'IS_NOT_BLANK';
+  }
+
+  private hasOnlyBlankRangeComparisons(filter: FilterConfig): boolean {
+    if (!filter?.rangeFilter?.length) return false;
+    let sawBlank = false;
+    for (const r of filter.rangeFilter) {
+      const parts = [r.fromCondition, r.toCondition, r.operator].filter(Boolean) as string[];
+      if (parts.length === 0) continue;
+      const hasNonBlank = parts.some((p) => !this.isBlankOperator(p));
+      if (hasNonBlank) return false;
+      const hasBlank = parts.some((p) => this.isBlankOperator(p));
+      if (hasBlank) sawBlank = true;
+    }
+    return sawBlank;
+  }
+
+  private buildColumnReferenceForWhere(filter: FilterConfig): string {
+    const source = BaseUtilities.getSource(this.options);
+    const idFromPayload = filter.columnIds?.[0];
+    const actualIdFromName =
+      (filter.tableNames?.[0] || '') && (filter.columnNames?.[0] || '')
+        ? `${filter.tableNames?.[0]}[${filter.columnNames?.[0]}]`
+        : filter.columnNames?.[0] || '';
+    const actualColumnId = BaseUtilities.extractColumnIdFromHierarchy(
+      idFromPayload || actualIdFromName,
+    );
+    const idForDb =
+      source === SOURCE_TYPES.BLEND ? idFromPayload || actualColumnId : actualColumnId;
+
+    const useDot = BaseUtilities.shouldUseDotNotation(this.options);
+    const tableName =
+      filter.tableNames?.[0] || BaseUtilities.getDefaultTableNameFromOptions(this.options);
+
+    if (useDot && tableName) {
+      return BaseUtilities.buildColumnReference(tableName, idForDb);
+    }
+    return `"${idForDb}"`;
+  }
+
+  private buildBlankRangeWhere(filter: FilterConfig): string {
+    if (!filter.rangeFilter?.length) return '';
+    const columnRef = this.buildColumnReferenceForWhere(filter);
+
+    const rangeConditions: string[] = [];
+    for (const r of filter.rangeFilter) {
+      const parts: string[] = [];
+      if (this.isBlankOperator(r.fromCondition)) {
+        parts.push(
+          `${columnRef} ${r.fromCondition?.toUpperCase() === 'IS_NOT_BLANK' ? 'IS NOT NULL' : 'IS NULL'}`,
+        );
+      }
+      if (this.isBlankOperator(r.toCondition)) {
+        parts.push(
+          `${columnRef} ${r.toCondition?.toUpperCase() === 'IS_NOT_BLANK' ? 'IS NOT NULL' : 'IS NULL'}`,
+        );
+      }
+      if (parts.length > 0) {
+        const joiner = (r.logicalOperator || 'AND').toUpperCase() === 'OR' ? 'OR' : 'AND';
+        rangeConditions.push(parts.length === 1 ? parts[0] : `(${parts.join(` ${joiner} `)})`);
+      }
+    }
+    const topJoiner = (filter.logicalOperator as 'AND' | 'OR') || 'AND';
+    return BaseUtilities.buildWhereCondition(rangeConditions, topJoiner);
+  }
+
+  private 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),
+    );
+  }
+
+  protected hasComplexFilters(): boolean {
+    return Boolean(
+      this.options.superFilters?.children?.some(
+        (child) => child.filters && this.isComplexFilter(child.filters),
+      ),
+    );
+  }
+
+  protected checkRankingFilters(): void {
+    if (!this.options.superFilters?.children) return;
+
+    const hasRankingFilter = this.options.superFilters.children.some(
+      (child) =>
+        Array.isArray(child.filters) &&
+        child.filters.some((filter: FilterConfig) => filter.filterType === 'RANKING'),
+    );
+
+    if (hasRankingFilter && !this.options.isRankingFilterIncluded) {
+      this.options.isRankingFilterIncluded = true;
+    }
+  }
+
+  private buildOrGroupCTE(): string {
+    const sf = this.options.superFilters;
+    if (!sf || sf.condition?.toUpperCase() !== 'OR' || !sf.children?.length) {
+      return '';
+    }
+
+    const dims = [
+      ...BaseUtilities.buildDimensionReference(this.options.rows, this.options),
+      ...BaseUtilities.buildDimensionReference(this.options.columns, this.options),
+    ];
+    if (dims.length === 0) return '';
+
+    const tableName = BaseUtilities.formatTableNameForDb(
+      BaseUtilities.getDefaultTableNameFromOptions(this.options),
+      this.options.databaseDetails?.databaseType as string,
+    );
+
+    const selectCols = dims.map((expr, idx) => `${expr} AS __or_dim${idx + 1}`).join(', ');
+
+    const parts: string[] = [];
+    sf.children.forEach((child) => {
+      const cond = this.buildSuperFilterChild(child);
+      if (cond && cond.trim()) {
+        parts.push(`SELECT DISTINCT ${selectCols} FROM ${tableName} WHERE ${cond}`);
+      }
+    });
+
+    if (parts.length === 0) return '';
+    return `__or_group AS (\n${parts.join('\nUNION\n')}\n)`;
+  }
+
+  buildOrGroupExistsClause(): string {
+    const sf = this.options.superFilters;
+    if (!sf || sf.condition?.toUpperCase() !== 'OR' || !sf.children?.length) {
+      return '';
+    }
+    const dims = [
+      ...BaseUtilities.buildDimensionReference(this.options.rows, this.options),
+      ...BaseUtilities.buildDimensionReference(this.options.columns, this.options),
+    ];
+    if (dims.length === 0) return '';
+    const comparisons = dims.map((expr, idx) => `${expr} = g.__or_dim${idx + 1}`).join(' AND ');
+    return `EXISTS (SELECT 1 FROM __or_group g WHERE ${comparisons})`;
+  }
+}

package/src/epm-query-builder/errors/QueryBuilderErrors.ts

@@ -0,0 +1,65 @@
+export abstract class QueryBuilderError extends Error {
+  abstract readonly code: string;
+
+  constructor(
+    message: string,
+    public readonly details?: Record<string, unknown>,
+  ) {
+    super(message);
+    this.name = this.constructor.name;
+    Error.captureStackTrace(this, this.constructor);
+  }
+}
+
+export class InvalidConfigurationError extends QueryBuilderError {
+  readonly code = 'INVALID_CONFIGURATION';
+
+  constructor(message: string, details?: Record<string, unknown>) {
+    super(`Configuration Error: ${message}`, details);
+  }
+}
+
+export class FilterValidationError extends QueryBuilderError {
+  readonly code = 'FILTER_VALIDATION_ERROR';
+
+  constructor(filterType: string, message: string, details?: Record<string, unknown>) {
+    super(`Filter Validation Error (${filterType}): ${message}`, details);
+  }
+}
+
+export class MeasureValidationError extends QueryBuilderError {
+  readonly code = 'MEASURE_VALIDATION_ERROR';
+
+  constructor(measureName: string, message: string, details?: Record<string, unknown>) {
+    super(`Measure Validation Error (${measureName}): ${message}`, details);
+  }
+}
+
+export class PaginationError extends QueryBuilderError {
+  readonly code = 'PAGINATION_ERROR';
+
+  constructor(command: string, message: string, details?: Record<string, unknown>) {
+    super(`Pagination Error (${command}): ${message}`, details);
+  }
+}
+
+export class QueryGenerationError extends QueryBuilderError {
+  readonly code = 'QUERY_GENERATION_ERROR';
+
+  constructor(message: string, details?: Record<string, unknown>) {
+    super(`Query Generation Error: ${message}`, details);
+  }
+}
+
+export class TableNotFoundError extends QueryBuilderError {
+  readonly code = 'TABLE_NOT_FOUND';
+
+  constructor(tableName?: string, details?: Record<string, unknown>) {
+    super(
+      tableName
+        ? `Table not found: ${tableName}`
+        : 'No table name found in configuration. Please specify tableName in rows, columns, or values.',
+      details,
+    );
+  }
+}

package/src/epm-query-builder/interfaces/IDatabaseQueryBuilder.ts

@@ -0,0 +1,5 @@
+// contract: dialect builders must implement this for query generation
+export interface IDatabaseQueryBuilder {
+  generateQuery(): string;
+  generateCountQuery?(): string;
+}

package/src/epm-query-builder/interfaces/index.ts

@@ -0,0 +1 @@
+export * from './IDatabaseQueryBuilder';