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

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

@@ -0,0 +1,65 @@
+import { BaseUtilities } from '@epm-query-builder/base/BaseUtilities';
+import { JoinPlan, JoinStep } from '@epm-query-builder/base/RelationshipResolver';
+import { SOURCE_TYPES } from '@epm-query-builder/constants/Source';
+import { EpmQueryBuilderOptions } from '@epm-query-builder/types/query-builder-types';
+
+function quoteTable(tableName: string, databaseType?: string): string {
+  return BaseUtilities.formatTableNameForDb(tableName, databaseType);
+}
+
+function quoteColumn(table: string, column: string): string {
+  return BaseUtilities.formatTableColumnReference(table, column);
+}
+
+function buildXmlaColumnRef(table: string, column: string): string {
+  const fullId = `${table}[${column}]`;
+  return `"${fullId}"`;
+}
+
+function buildJoin(
+  step: JoinStep,
+  databaseType: string | undefined,
+  options?: EpmQueryBuilderOptions,
+): string {
+  const source = options ? BaseUtilities.getSource(options) : '';
+  const isXmla = source === SOURCE_TYPES.XMLA;
+
+  const leftExpr = isXmla
+    ? buildXmlaColumnRef(step.leftTable, step.leftColumn)
+    : quoteColumn(step.leftTable, step.leftColumn);
+  const rightExpr = isXmla
+    ? buildXmlaColumnRef(step.rightTable, step.rightColumn)
+    : quoteColumn(step.rightTable, step.rightColumn);
+
+  let rightSource = quoteTable(step.rightTable, databaseType);
+  if (step.dedupeRightOn) {
+    if (isXmla) {
+      const keyRef = buildXmlaColumnRef(step.rightTable, step.dedupeRightOn);
+      const fullId = `${step.rightTable}[${step.dedupeRightOn}]`;
+      rightSource = `(
+            SELECT DISTINCT ${keyRef} AS "${fullId}"
+            FROM ${quoteTable(step.rightTable, databaseType)}
+        ) ${quoteTable(step.rightTable, databaseType)}`;
+    } else {
+      const keyCol = quoteColumn(step.rightTable, step.dedupeRightOn);
+      rightSource = `(
+            SELECT DISTINCT ${keyCol} AS "${step.dedupeRightOn}"
+            FROM ${quoteTable(step.rightTable, databaseType)}
+        ) ${quoteTable(step.rightTable, databaseType)}`;
+    }
+  }
+
+  const on = `${leftExpr} = ${rightExpr}`;
+  return `${step.joinType} JOIN ${rightSource} ON ${on}`;
+}
+
+export class DuckDbJoinBuilder {
+  static buildJoinClauses(
+    plan: JoinPlan,
+    databaseType: string | undefined,
+    options?: EpmQueryBuilderOptions,
+  ): string[] {
+    if (!plan.joins?.length) return [];
+    return plan.joins.map((j) => buildJoin(j, databaseType, options));
+  }
+}

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

@@ -0,0 +1,626 @@
+import { BaseMeasureBuilder } from '@epm-query-builder/base/BaseMeasureBuilder';
+import {
+  MeasureConfig,
+  FilterConfig,
+  EpmQueryBuilderOptions,
+  SuperFilterChild,
+} from '@epm-query-builder/types/query-builder-types';
+import { BaseUtilities } from '@epm-query-builder/base/BaseUtilities';
+import { BaseAnalyticalFunctions } from '@epm-query-builder/base/BaseAnalyticalFunctions';
+import { BaseAdvancedAggregations } from '@epm-query-builder/base/BaseAdvancedAggregations';
+import { DuckDbAdvancedAggregations } from './DuckDbAdvancedAggregations';
+import { SOURCE_TYPES } from '@epm-query-builder/constants/Source';
+
+export class DuckDbMeasureBuilder extends BaseMeasureBuilder {
+  private analyticalFunctions: BaseAnalyticalFunctions;
+  private advancedAggregations: BaseAdvancedAggregations;
+  private duckDbAdvancedAggregations: DuckDbAdvancedAggregations;
+
+  constructor(options: EpmQueryBuilderOptions) {
+    super(options);
+    this.analyticalFunctions = new BaseAnalyticalFunctions(options);
+    this.advancedAggregations = new BaseAdvancedAggregations(options);
+    this.duckDbAdvancedAggregations = new DuckDbAdvancedAggregations(options);
+  }
+
+  buildMeasureSelects(): string[] {
+    const measures = this.getMeasures();
+    const columns: string[] = [];
+
+    measures.forEach((measure) => {
+      let measureExpr: string;
+      if (this.isMeasureType(measure)) {
+        measureExpr = this.buildCalculatedMeasure(measure);
+      } else if (this.isAnalyticalMeasure(measure)) {
+        measureExpr = this.buildAnalyticalMeasure(measure, measure.aggregationType || 'SUM');
+      } else if (this.isAdvancedAggregation(measure)) {
+        measureExpr = this.buildAdvancedAggregation(measure, measure.aggregationType || 'SUM');
+      } else {
+        measureExpr = this.buildDuckDbAggregation(measure);
+      }
+
+      columns.push(measureExpr);
+
+      if (this.options.isCrossHighlightEnabled && this.hasCrossHighlightFilters()) {
+        const crossHighlightExpr = this.buildCrossHighlightMeasure(measure);
+        const alias = measure.label || measure.columnName;
+        columns.push(`${crossHighlightExpr} AS "${alias}_CrossHighlight"`);
+      }
+    });
+
+    this.addCustomMeasures(columns);
+    this.addDimensionIdMeasures(columns);
+
+    return columns;
+  }
+
+  buildMeasureFilterCTE(): string {
+    const measureFilters = this.extractMeasureFilters();
+
+    if (measureFilters.length === 0) {
+      return '';
+    }
+
+    const filterCTEs = measureFilters
+      .filter((filter): filter is FilterConfig => 'filterType' in filter)
+      .map((filter, index) => this.generateMeasureFilterCTE(filter, index + 1));
+
+    return filterCTEs.join(',\n');
+  }
+
+  buildHavingClause(): string {
+    const measureFilters = this.extractMeasureFilters();
+
+    if (measureFilters.length === 0) {
+      return '';
+    }
+
+    const conditions = measureFilters
+      .filter((filter): filter is FilterConfig => 'filterType' in filter)
+      .map((filter) => this.buildMeasureFilterCondition(filter))
+      .filter((condition) => condition);
+
+    if (conditions.length === 0) {
+      return '';
+    }
+
+    const combined = BaseUtilities.combineConditions(conditions, 'AND');
+
+    const dims = this.extractDimensions();
+    if (dims.length > 0) {
+      const isLeaf = dims.map((d) => `GROUPING(${d}) = 0`).join(' AND ');
+      return `((${isLeaf}) AND (${combined})) OR (NOT (${isLeaf}))`;
+    }
+
+    return combined;
+  }
+
+  protected buildDuckDbAggregation(measure: MeasureConfig): string {
+    const aggregationType = this.mapDuckDbAggregationType(measure.aggregationType);
+    const originalAgg = measure.aggregationType?.toUpperCase();
+    const hasAggregation = measure.aggregationType && measure.aggregationType.trim() !== '';
+
+    const source = BaseUtilities.getSource(this.options);
+    const isBlend = source === SOURCE_TYPES.BLEND;
+    if (isBlend) {
+      const actualColumnId = BaseUtilities.extractColumnIdFromHierarchy(measure.id);
+      const tableForBlend =
+        measure.tableName || BaseUtilities.getDefaultTableNameFromOptions(this.options) || '';
+
+      // If no aggregation type, use column name directly without prefix for the alias
+      // but still apply SUM for the aggregation to satisfy GROUP BY requirements
+      const aliasName = hasAggregation
+        ? `${(measure.aggregationType || aggregationType).toUpperCase()}__${actualColumnId}`
+        : actualColumnId;
+      const qualifiedInnerRef = `"${tableForBlend}"."${aliasName}"`;
+
+      // If no aggregation type, apply SUM but use clean alias without prefix
+      if (!hasAggregation) {
+        return `SUM(${qualifiedInnerRef}) as "${aliasName}"`;
+      }
+
+      if (originalAgg === 'FIRST') {
+        return `MIN(${qualifiedInnerRef}) as "${aliasName}"`;
+      }
+      if (originalAgg === 'LAST') {
+        return `MAX(${qualifiedInnerRef}) as "${aliasName}"`;
+      }
+      if (
+        originalAgg === 'COUNT_DISTINCT' ||
+        originalAgg === 'DISTINCT_COUNT' ||
+        originalAgg === 'DISTINCTCOUNT'
+      ) {
+        return `COUNT(DISTINCT ${qualifiedInnerRef}) as "${aliasName}"`;
+      }
+
+      return `${aggregationType}(${qualifiedInnerRef}) as "${aliasName}"`;
+    }
+
+    let columnRef: string;
+    if (this.options.databaseDetails?.databaseType === 'duckdb') {
+      const actualColumnId = BaseUtilities.extractColumnIdFromHierarchy(measure.id);
+      columnRef = `"${actualColumnId}"`;
+    } else {
+      const actualColumnId = BaseUtilities.extractColumnIdFromHierarchy(measure.id);
+      const effectiveColumnName = measure.columnName || actualColumnId;
+      columnRef = `${measure.tableName}.${effectiveColumnName}`;
+    }
+
+    let aggregationExpr: string;
+
+    // If no aggregation type, apply default SUM aggregation but use clean alias without prefix
+    if (!hasAggregation) {
+      aggregationExpr = `SUM(${columnRef}) as ${columnRef}`;
+    } else if (originalAgg === 'FIRST') {
+      aggregationExpr = `MIN(${columnRef}) as "FIRST__${columnRef.replace(/"/g, '')}"`;
+    } else if (originalAgg === 'LAST') {
+      aggregationExpr = `MAX(${columnRef}) as "LAST__${columnRef.replace(/"/g, '')}"`;
+    } else {
+      switch (aggregationType) {
+        case 'COUNT':
+          if (
+            measure.aggregationType?.toUpperCase() === 'COUNT_DISTINCT' ||
+            measure.aggregationType?.toUpperCase() === 'DISTINCT_COUNT' ||
+            measure.aggregationType?.toUpperCase() === 'DISTINCTCOUNT'
+          ) {
+            aggregationExpr = `COUNT(DISTINCT ${columnRef}) as "COUNT_DISTINCT__${columnRef.replace(/"/g, '')}"`;
+          } else {
+            aggregationExpr = `COUNT(${columnRef}) as "COUNT__${columnRef.replace(/"/g, '')}"`;
+          }
+          break;
+        case 'STRING_AGG':
+          aggregationExpr = `STRING_AGG(${columnRef}) as "STRING_AGG__${columnRef.replace(/"/g, '')}"`;
+          break;
+        case 'MEDIAN':
+          aggregationExpr = `MEDIAN(${columnRef}) as "MEDIAN__${columnRef.replace(/"/g, '')}"`;
+          break;
+        case 'MODE':
+          aggregationExpr = `MODE(${columnRef}) as "MODE__${columnRef.replace(/"/g, '')}"`;
+          break;
+        case 'CONCATENATED':
+          aggregationExpr = `STRING_AGG(${columnRef}) as "CONCATENATED__${columnRef.replace(/"/g, '')}"`;
+          break;
+        case 'CONCATENATED_IDS':
+          aggregationExpr = `STRING_AGG(${columnRef}) as "CONCATENATED_IDS__${columnRef.replace(/"/g, '')}"`;
+          break;
+        default:
+          aggregationExpr = `${aggregationType}(${columnRef}) as "${aggregationType}__${columnRef.replace(/"/g, '')}"`;
+      }
+    }
+
+    if (this.needsFilterClause()) {
+      const filterCondition = this.buildMeasureFilterForAggregation();
+      if (this.options.databaseDetails?.databaseType === 'duckdb') {
+        return `${aggregationExpr} FILTER (WHERE ${filterCondition})`;
+      }
+      return `${aggregationExpr} FILTER (WHERE ${filterCondition}) AS "${measure.label}"`;
+    }
+
+    if (this.options.databaseDetails?.databaseType === 'duckdb') {
+      return aggregationExpr;
+    }
+    return `${aggregationExpr} AS "${measure.label}"`;
+  }
+
+  private mapDuckDbAggregationType(aggregationType?: string): string {
+    if (!aggregationType) return 'SUM';
+
+    const duckDbMapping: Record<string, string> = {
+      SUM: 'SUM',
+      COUNT: 'COUNT',
+      AVG: 'AVG',
+      MIN: 'MIN',
+      MAX: 'MAX',
+
+      FIRST: 'MIN',
+      LAST: 'MAX',
+      STANDARD_DEVIATION: 'STDDEV_POP',
+      VARIANCE: 'VAR_POP',
+      COUNT_DISTINCT: 'COUNT',
+      MEDIAN: 'MEDIAN',
+      MODE: 'MODE',
+
+      CONCATENATED: 'STRING_AGG',
+      CONCATENATED_IDS: 'STRING_AGG',
+
+      DISTINCTCOUNT: 'COUNT',
+      DISTINCT_COUNT: 'COUNT',
+      COUNTA: 'COUNT',
+      AVERAGE: 'AVG',
+      MINIMUM: 'MIN',
+      MAXIMUM: 'MAX',
+    };
+
+    return duckDbMapping[aggregationType.toUpperCase()] || aggregationType.toUpperCase();
+  }
+
+  private extractMeasureFilters(): FilterConfig[] {
+    if (!this.options.superFilters?.children) {
+      return [];
+    }
+
+    const measureFilters: FilterConfig[] = [];
+    this.extractMeasureFiltersRecursively(this.options.superFilters.children, measureFilters);
+    return measureFilters;
+  }
+
+  private extractMeasureFiltersRecursively(
+    children: SuperFilterChild[],
+    measureFilters: FilterConfig[],
+  ): void {
+    children.forEach((child) => {
+      if (child.filters) {
+        const filter = child.filters;
+        const isMeasureFilterType = filter.filterType === 'MEASURE';
+        const hasMeasureColumnType = Array.isArray(filter.columnType)
+          ? filter.columnType.some((type) => type?.toUpperCase() === 'MEASURE')
+          : false;
+        const isAggregatedRange =
+          filter.filterType === 'RANGE' &&
+          Array.isArray(filter.aggregationType) &&
+          filter.aggregationType.length > 0;
+
+        if (isMeasureFilterType || hasMeasureColumnType || isAggregatedRange) {
+          measureFilters.push(filter);
+        }
+      }
+
+      if (child.children) {
+        this.extractMeasureFiltersRecursively(child.children, measureFilters);
+      }
+    });
+  }
+
+  private generateMeasureFilterCTE(filter: FilterConfig, counter: number): string {
+    const variableName = `measure_filter_${counter}`;
+
+    if (!filter.rangeFilter?.length) {
+      return '';
+    }
+
+    const tableName = filter.tableNames?.[0] || '';
+    const aggregationType = this.mapDuckDbAggregationType(filter.aggregationType?.[0]);
+    const columnRef = this.resolveColumnRef(filter);
+
+    const conditions = this.buildRangeConditionsForAggregation(columnRef, filter, aggregationType);
+
+    const dims = this.extractDimensions();
+    if (dims.length === 0) {
+      return '';
+    }
+    const selectDims = dims.map((d, idx) => `${d} AS __mf_dim${idx + 1}`).join(', ');
+    const groupByDims = dims.join(', ');
+
+    return `${variableName} AS (
+            SELECT ${selectDims}
+            FROM ${tableName}
+            GROUP BY ${groupByDims}
+            HAVING ${conditions.join(' AND ')}
+        )`;
+  }
+
+  private buildMeasureFilterCondition(filter: FilterConfig): string {
+    if (!filter.rangeFilter?.length) {
+      return '';
+    }
+
+    const aggregationType = this.mapDuckDbAggregationType(filter.aggregationType?.[0]);
+    const columnRef = this.resolveColumnRef(filter);
+    const conditions = this.buildRangeConditionsForAggregation(columnRef, filter, aggregationType);
+    return conditions.length === 1 ? conditions[0] : `(${conditions.join(' AND ')})`;
+  }
+
+  private needsFilterClause(): boolean {
+    return false;
+  }
+
+  private buildMeasureFilterForAggregation(): string {
+    return '1=1';
+  }
+
+  buildMeasureFilterWhereClause(): string {
+    const measureFilters = this.extractMeasureFilters();
+    if (measureFilters.length === 0) {
+      return '';
+    }
+    const dims = this.extractDimensions();
+    if (dims.length === 0) {
+      return '';
+    }
+
+    const clauses: string[] = [];
+    let counter = 0;
+    for (const f of measureFilters) {
+      if (!('filterType' in f)) continue;
+      if (!f.rangeFilter?.length) continue;
+      counter += 1;
+      const eqs = dims.map((d, idx) => `${d} = mf.__mf_dim${idx + 1}`).join(' AND ');
+      clauses.push(`EXISTS (SELECT 1 FROM measure_filter_${counter} mf WHERE ${eqs})`);
+    }
+    return BaseUtilities.combineConditions(clauses.filter(Boolean), 'AND');
+  }
+
+  private extractDimensions(): string[] {
+    const rowDimensions = BaseUtilities.buildDimensionReference(this.options.rows, this.options);
+    const columnDimensions = BaseUtilities.buildDimensionReference(
+      this.options.columns,
+      this.options,
+    );
+    return [...rowDimensions, ...columnDimensions];
+  }
+
+  private combineFilterConditions(conditions: string[], operator: 'AND' | 'OR' = 'AND'): string {
+    return BaseUtilities.combineConditions(conditions, operator);
+  }
+
+  private hasCrossHighlightFilters(): boolean {
+    return Boolean(
+      this.options.superFilters?.children?.some(
+        (child) =>
+          Array.isArray(child.filters) &&
+          child.filters.some((filter: FilterConfig) => filter.isCrossHighlight),
+      ),
+    );
+  }
+
+  private buildCrossHighlightMeasure(measure: MeasureConfig): string {
+    const baseAggregation = this.buildDuckDbAggregation(measure);
+    const crossHighlightConditions = this.getCrossHighlightConditions();
+
+    if (!crossHighlightConditions.length) {
+      return baseAggregation;
+    }
+
+    const whereClause = crossHighlightConditions.join(' AND ');
+    return `CASE WHEN ${whereClause} THEN ${baseAggregation} ELSE NULL END`;
+  }
+
+  private getCrossHighlightConditions(): string[] {
+    const conditions: string[] = [];
+
+    if (!this.options.superFilters?.children) return conditions;
+
+    this.options.superFilters.children.forEach((child) => {
+      if (Array.isArray(child.filters)) {
+        child.filters.forEach((filter: FilterConfig) => {
+          if (
+            filter.isCrossHighlight &&
+            filter.columnNames?.length &&
+            filter.valuesFilter?.length
+          ) {
+            const tableName =
+              filter.tableNames?.[0] || BaseUtilities.getDefaultTableNameFromOptions(this.options);
+            const columnName = filter.columnNames[0];
+            const columnRef = `"${tableName}"."${columnName}"`;
+
+            if (filter.valuesFilter.length === 1) {
+              const value = filter.valuesFilter[0];
+              const displayValue = typeof value === 'object' ? value.id : value;
+              conditions.push(`${columnRef} = '${displayValue}'`);
+            } else {
+              const valuesList = filter.valuesFilter
+                .map((v) => `'${typeof v === 'object' ? v.id : v}'`)
+                .join(', ');
+              conditions.push(`${columnRef} IN (${valuesList})`);
+            }
+          }
+        });
+      }
+    });
+
+    return conditions;
+  }
+
+  private addCustomMeasures(columns: string[]): void {
+    if (!this.options.customMeasures?.length) return;
+
+    this.options.customMeasures.forEach((customMeasure) => {
+      const duckDbMeasure = this.convertCustomMeasure(customMeasure);
+      if (duckDbMeasure && duckDbMeasure.trim()) {
+        columns.push(duckDbMeasure);
+      }
+    });
+  }
+
+  private convertCustomMeasure(measure: string): string {
+    if (measure.includes('CONCATENATEX')) {
+      const convertedMeasure = measure
+        .replace(/CONCATENATEX\s*\(/gi, 'STRING_AGG(')
+        .replace(/,\s*","\s*\)/gi, ", ',' ORDER BY 1)")
+        .replace(/,\s*"\|"\s*\)/gi, ", '|' ORDER BY 1)");
+      return convertedMeasure;
+    }
+
+    return measure;
+  }
+
+  private addDimensionIdMeasures(columns: string[]): void {
+    if (!this.options.dimensionIdMappings) return;
+
+    Object.entries(this.options.dimensionIdMappings).forEach(([tableName, mappings]) => {
+      if (mappings && mappings.length > 0) {
+        const concatenatedColumns = mappings
+          .map((mapping) => `"${tableName}"."${mapping.targetField}"`)
+          .join(" || '|' || ");
+
+        columns.push(`${concatenatedColumns} AS "${tableName}_ConcatenatedIds"`);
+      }
+    });
+  }
+
+  private isAnalyticalMeasure(measure: MeasureConfig): boolean {
+    const analyticalTypes = [
+      'ROW_NUMBER',
+      'RANK',
+      'DENSE_RANK',
+      'PERCENT_RANK',
+      'LAG',
+      'LEAD',
+      'CUMULATIVE_SUM',
+      'CUMULATIVE_COUNT',
+      'MOVING_AVG',
+      'PERCENTILE_25',
+      'PERCENTILE_75',
+      'MEDIAN',
+    ];
+    return Boolean(
+      measure.aggregationType && analyticalTypes.includes(measure.aggregationType.toUpperCase()),
+    );
+  }
+
+  private isAdvancedAggregation(measure: MeasureConfig): boolean {
+    const advancedTypes = [
+      'ARRAY_AGG',
+      'ARRAY_AGG_DISTINCT',
+      'JSON_AGG',
+      'APPROX_COUNT_DISTINCT',
+      'PRODUCT',
+      'GEOMETRIC_MEAN',
+      'HARMONIC_MEAN',
+      'MAD',
+      'STRING_AGG_SEMICOLON',
+      'STRING_AGG_PIPE',
+      'HISTOGRAM',
+      'QUANTILES',
+      'RESERVOIR_SAMPLE',
+      'BIT_AND',
+      'BIT_OR',
+      'BIT_XOR',
+      'BOOL_AND',
+      'BOOL_OR',
+    ];
+    return Boolean(
+      measure.aggregationType && advancedTypes.includes(measure.aggregationType.toUpperCase()),
+    );
+  }
+
+  buildAnalyticalMeasure(measure: MeasureConfig, analyticalType: string): string {
+    switch (analyticalType.toUpperCase()) {
+      case 'ROW_NUMBER':
+        return this.analyticalFunctions.buildRankingFunction(measure, 'ROW_NUMBER');
+      case 'RANK':
+        return this.analyticalFunctions.buildRankingFunction(measure, 'RANK');
+      case 'DENSE_RANK':
+        return this.analyticalFunctions.buildRankingFunction(measure, 'DENSE_RANK');
+      case 'PERCENT_RANK':
+        return this.analyticalFunctions.buildRankingFunction(measure, 'PERCENT_RANK');
+      case 'LAG':
+        return this.analyticalFunctions.buildLagLeadFunction(measure, 'LAG', 1);
+      case 'LEAD':
+        return this.analyticalFunctions.buildLagLeadFunction(measure, 'LEAD', 1);
+      case 'CUMULATIVE_SUM':
+        return this.analyticalFunctions.buildCumulativeAggregation(measure, 'SUM');
+      case 'CUMULATIVE_COUNT':
+        return this.analyticalFunctions.buildCumulativeAggregation(measure, 'COUNT');
+      case 'MOVING_AVG':
+        return this.analyticalFunctions.buildMovingAggregation(measure, 'AVG', 3);
+      case 'PERCENTILE_25':
+        return this.analyticalFunctions.buildPercentileFunction(measure, 0.25);
+      case 'PERCENTILE_75':
+        return this.analyticalFunctions.buildPercentileFunction(measure, 0.75);
+      case 'MEDIAN':
+        return this.buildDuckDbAggregation(measure);
+      default:
+        return this.buildDuckDbAggregation(measure);
+    }
+  }
+
+  buildAdvancedAggregation(
+    measure: MeasureConfig,
+    aggregationType: string,
+    options?: Record<string, unknown>,
+  ): string {
+    switch (aggregationType.toUpperCase()) {
+      case 'STRING_AGG_SEMICOLON':
+        return this.advancedAggregations.buildStringAggregation(measure, '; ', false);
+      case 'STRING_AGG_PIPE':
+        return this.advancedAggregations.buildStringAggregation(measure, ' | ', false);
+      case 'HISTOGRAM': {
+        const binCount = (options?.binCount as number) || 10;
+        return this.duckDbAdvancedAggregations.buildHistogramAggregation(measure, binCount);
+      }
+      case 'QUANTILES': {
+        const quantiles = (options?.quantiles as number[]) || [0.25, 0.5, 0.75];
+        return this.duckDbAdvancedAggregations.buildQuantileAggregation(measure, quantiles);
+      }
+      case 'RESERVOIR_SAMPLE': {
+        const sampleSize = (options?.sampleSize as number) || 100;
+        return this.duckDbAdvancedAggregations.buildReservoirSample(measure, sampleSize);
+      }
+      case 'BIT_AND':
+        return this.advancedAggregations.buildBitAggregations(measure, 'AND');
+      case 'BIT_OR':
+        return this.advancedAggregations.buildBitAggregations(measure, 'OR');
+      case 'BIT_XOR':
+        return this.advancedAggregations.buildBitAggregations(measure, 'XOR');
+      case 'BOOL_AND':
+        return this.advancedAggregations.buildBoolAggregations(measure, 'AND');
+      case 'BOOL_OR':
+        return this.advancedAggregations.buildBoolAggregations(measure, 'OR');
+      default:
+        return this.buildDuckDbAggregation(measure);
+    }
+  }
+
+  private resolveColumnRef(filter: FilterConfig): string {
+    if (this.options.databaseDetails?.databaseType === 'duckdb') {
+      const actualId = BaseUtilities.extractColumnIdFromHierarchy(
+        filter.columnIds?.[0] ||
+          `${filter.tableNames?.[0] || ''}[${filter.columnNames?.[0] || ''}]`,
+      );
+      return `"${actualId}"`;
+    }
+    const tableName = filter.tableNames?.[0] || '';
+    const column = filter.columnNames?.[0] || '';
+    return `${tableName}.${column}`;
+  }
+
+  private buildRangeConditionsForAggregation(
+    columnRef: string,
+    filter: FilterConfig,
+    aggregationType: string,
+  ): string[] {
+    const conditions: string[] = [];
+    filter.rangeFilter?.forEach((range) => {
+      const rangeParts: string[] = [];
+      if (range.from !== undefined && range.fromCondition) {
+        const op = this.normalizeOperator(range.fromCondition);
+        if (op === 'IS NULL' || op === 'IS NOT NULL') {
+          rangeParts.push(`${aggregationType}(${columnRef}) ${op}`);
+        } else {
+          const value = typeof range.from === 'string' ? `'${range.from}'` : range.from;
+          rangeParts.push(`${aggregationType}(${columnRef}) ${op} ${value}`);
+        }
+      }
+      if (range.to !== undefined && range.toCondition) {
+        const op = this.normalizeOperator(range.toCondition);
+        if (op === 'IS NULL' || op === 'IS NOT NULL') {
+          rangeParts.push(`${aggregationType}(${columnRef}) ${op}`);
+        } else {
+          const value = typeof range.to === 'string' ? `'${range.to}'` : range.to;
+          rangeParts.push(`${aggregationType}(${columnRef}) ${op} ${value}`);
+        }
+      }
+      if (rangeParts.length === 0 && range.operator && range.value !== undefined) {
+        const op = this.normalizeOperator(range.operator);
+        if (op === 'IS NULL' || op === 'IS NOT NULL') {
+          rangeParts.push(`${aggregationType}(${columnRef}) ${op}`);
+        } else {
+          const value = typeof range.value === 'string' ? `'${range.value}'` : range.value;
+          rangeParts.push(`${aggregationType}(${columnRef}) ${op} ${value}`);
+        }
+      }
+      if (rangeParts.length > 0) {
+        const joiner = (range.logicalOperator || 'AND').toUpperCase() === 'OR' ? 'OR' : 'AND';
+        conditions.push(
+          rangeParts.length === 1 ? rangeParts[0] : `(${rangeParts.join(` ${joiner} `)})`,
+        );
+      }
+    });
+    return conditions;
+  }
+
+  private normalizeOperator(op: string): string {
+    return BaseUtilities.normalizeComparisonOperator(op);
+  }
+}