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

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

@@ -0,0 +1,853 @@
+// duckdb dialect: concrete builder for duckdb
+import { BaseQueryBuilder } from '@epm-query-builder/base/BaseQueryBuilder';
+import {
+  SuperFilterChild,
+  RowColumnConfig,
+  RankingConfig,
+  EpmQueryBuilderOptions,
+} from '@epm-query-builder/types/query-builder-types';
+import { BaseUtilities } from '@epm-query-builder/base/BaseUtilities';
+import { DuckDbSuperFilterBuilder } from './DuckDbSuperFilterBuilder';
+import { DuckDbMeasureBuilder } from './DuckDbMeasureBuilder';
+import { DuckDbRollupBuilder } from './DuckDbRollupBuilder';
+import { DuckDbPaginationBuilder } from './DuckDbPaginationBuilder';
+import { DuckDbOrderBuilder } from './DuckDbOrderBuilder';
+import { BaseCountQueryBuilder } from '@epm-query-builder/base/BaseCountQueryBuilder';
+import { QueryOptionsValidator } from '@epm-query-builder/validation/QueryOptionsValidator';
+import { SqlQueryValidator } from '@epm-query-builder/validation/SqlQueryValidator';
+import { QueryGenerationError } from '@epm-query-builder/errors/QueryBuilderErrors';
+import { IDatabaseQueryBuilder } from '@epm-query-builder/interfaces';
+import { resolveJoinPlan } from '@epm-query-builder/base/RelationshipResolver';
+import { DuckDbJoinBuilder } from './DuckDbJoinBuilder';
+import { SOURCE_TYPES } from '@epm-query-builder/constants/Source';
+
+export class DuckDbQueryBuilder extends BaseQueryBuilder implements IDatabaseQueryBuilder {
+  private superFilterBuilder: DuckDbSuperFilterBuilder;
+  private measureBuilder: DuckDbMeasureBuilder;
+  private rollupBuilder: DuckDbRollupBuilder;
+  private paginationBuilder: DuckDbPaginationBuilder;
+  private orderBuilder: DuckDbOrderBuilder;
+  private countQueryBuilder: BaseCountQueryBuilder;
+
+  constructor(options: EpmQueryBuilderOptions) {
+    super(options);
+    // order matters: these builders are used throughout generation
+    this.superFilterBuilder = new DuckDbSuperFilterBuilder(options);
+    this.measureBuilder = new DuckDbMeasureBuilder(options);
+    this.rollupBuilder = new DuckDbRollupBuilder(options);
+    this.paginationBuilder = new DuckDbPaginationBuilder(options);
+    this.orderBuilder = new DuckDbOrderBuilder(options);
+    this.countQueryBuilder = new BaseCountQueryBuilder(options);
+  }
+
+  // orchestrates decision between analytical and simple queries
+  generateQuery(): string {
+    try {
+      QueryOptionsValidator.validateBasicConfiguration(this.options);
+
+      const hasMultipleTables = this.containsDifferentTables();
+      const hasMeasureInValues = this.hasMeasureInValues();
+
+      // multi-table without measures uses ctes path
+      if (hasMultipleTables && !hasMeasureInValues) {
+        const multiTableQuery = this.generateMultiTableQuery();
+        SqlQueryValidator.validateQuery(multiTableQuery);
+        return multiTableQuery;
+      }
+
+      let query: string;
+      if (this.shouldGenerateAnalyticalQuery()) {
+        query = this.generateAnalyticalQuery();
+      } else {
+        query = this.generateSimpleQuery();
+      }
+
+      SqlQueryValidator.validateQuery(query);
+      return query;
+    } catch (error) {
+      if (error instanceof Error && error.name.includes('Error')) {
+        throw error;
+      }
+
+      throw new QueryGenerationError(`Failed to generate query: ${error}`, {
+        originalError: error,
+        hasRows: Boolean(this.options.rows?.length),
+        hasColumns: Boolean(this.options.columns?.length),
+        hasValues: Boolean(this.options.values?.length),
+      });
+    }
+  }
+
+  generateCountQuery(): string {
+    const mainQuery = this.generateQuery();
+    const countQuery = this.countQueryBuilder.generateCountQuery(mainQuery);
+
+    SqlQueryValidator.validateCountQuery(countQuery);
+    return countQuery;
+  }
+
+  // builds query for multi-table scenarios using ctes
+  private generateMultiTableQuery(): string {
+    const dimensions = BaseUtilities.extractDimensionsFromOptions(this.options);
+    const measures = this.extractMeasures();
+    const cteQueries = this.buildCTEs();
+    const source = BaseUtilities.getSource(this.options);
+    const isXmla = source === SOURCE_TYPES.XMLA;
+
+    const selectParts: string[] = [];
+
+    if (dimensions.length > 0) {
+      if (this.options.rows?.length) {
+        this.options.rows.forEach((row) => {
+          const column = BaseUtilities.formatColumnReferenceForDb(row, this.options);
+          selectParts.push(`${column} AS "${row.id}"`);
+        });
+      }
+      if (this.options.columns?.length) {
+        this.options.columns.forEach((col) => {
+          const column = BaseUtilities.formatColumnReferenceForDb(col, this.options);
+          selectParts.push(`${column} AS "${col.id}"`);
+        });
+      }
+    }
+
+    if (measures.length > 0) {
+      const measureSelects = this.measureBuilder.buildMeasureSelects();
+      selectParts.push(...measureSelects);
+    }
+
+    const fromClause = this.buildFromWithJoins();
+    const whereConditions = [
+      this.superFilterBuilder.buildWhereClause(),
+      this.superFilterBuilder.buildOrGroupExistsClause?.()
+        ? this.superFilterBuilder.buildOrGroupExistsClause()
+        : '',
+    ].filter(Boolean);
+
+    const hasMeasures = measures.length > 0;
+    const shouldGroupBy = dimensions.length > 0 && (!isXmla || hasMeasures);
+
+    const selectClause =
+      isXmla && !hasMeasures
+        ? `SELECT DISTINCT ${selectParts.join(', ')}`
+        : this.buildSelectClause(selectParts);
+
+    return this.buildCompleteQuery({
+      cte: cteQueries,
+      select: selectClause,
+      from: fromClause,
+      where: this.buildWhereClause(whereConditions),
+      groupBy: shouldGroupBy ? this.buildGroupByClause(dimensions) : undefined,
+      orderBy: this.orderBuilder.buildOrderByClause(),
+      limit: this.paginationBuilder.buildLimitClause(),
+    });
+  }
+
+  // analytical path: generates ctes then main
+  private generateAnalyticalQuery(): string {
+    const cteQueries = this.buildCTEs();
+    const mainQuery = this.buildMainQuery();
+
+    if (cteQueries) {
+      return `${cteQueries}\n${mainQuery}`;
+    }
+    return mainQuery;
+  }
+
+  // simple path: handles select all, distinct, or aggregate
+  private generateSimpleQuery(): string {
+    const tableName = this.getDefaultTableName();
+    const dimensions = BaseUtilities.extractDimensionsFromOptions(this.options);
+    const whereClause = this.superFilterBuilder.buildWhereClause();
+
+    if (this.isSelectAllRequested() && !this.hasMeasures() && !this.hasRankingFilters()) {
+      return this.buildSelectAllQuery(tableName, whereClause);
+    }
+
+    if (!this.hasMeasures()) {
+      if (this.hasRankingFilters()) {
+        return this.buildTopNRankingQuery(tableName, dimensions);
+      }
+      return this.buildDistinctQuery(tableName, dimensions, whereClause);
+    }
+    return this.buildSimpleAggregateQuery(tableName, dimensions, whereClause);
+  }
+
+  // collects ctes for filters and pre-processing
+  private buildCTEs(): string {
+    const ctes: string[] = [];
+
+    if (this.hasComplexFilters()) {
+      const filterCTE = this.superFilterBuilder.buildFilterCTE();
+      if (filterCTE) {
+        ctes.push(filterCTE);
+      }
+    }
+
+    const measureFilterCTEs = this.measureBuilder.buildMeasureFilterCTE();
+    if (measureFilterCTEs) {
+      ctes.push(measureFilterCTEs);
+    }
+
+    const rankingCTE = this.buildRankingKeysCTE();
+    if (rankingCTE) {
+      ctes.push(rankingCTE);
+    }
+
+    return ctes.length > 0 ? `WITH ${ctes.join(',\n')}` : '';
+  }
+
+  // assembles main query parts respecting ranking overrides
+  private buildMainQuery(): string {
+    const selectItems = this.buildSelectItems();
+    const whereConditions = [
+      this.superFilterBuilder.buildWhereClause(),
+      this.measureBuilder.buildMeasureFilterWhereClause(),
+    ].filter(Boolean);
+    const groupByColumns = this.buildGroupByColumns();
+    const havingConditions = [this.measureBuilder.buildHavingClause()].filter(Boolean);
+
+    const hasRanking = Boolean(this.options.isRankingFilterIncluded) || this.hasRankingFilters();
+
+    if (this.shouldGenerateRollup() && hasRanking) {
+      const nullFilterConditions = this.rollupBuilder.buildNullFilterConditions();
+      whereConditions.push(...nullFilterConditions);
+    }
+
+    let orderByClause = this.orderBuilder.buildOrderByClause();
+    let limitClause = this.paginationBuilder.buildLimitClause();
+
+    const ranking = this.findFirstRankingConfig(this.options.superFilters?.children || []);
+    if (ranking) {
+      const rankingOrder = this.buildRankingOrderClause(ranking);
+      const dimsForHaving = BaseUtilities.extractDimensionsFromOptions(this.options);
+      const hasRollup = this.shouldGenerateRollup();
+
+      if (rankingOrder) {
+        orderByClause = hasRollup
+          ? `ORDER BY "[IsRowGrandTotal]" DESC NULLS LAST, ${rankingOrder}`
+          : `ORDER BY ${rankingOrder}`;
+      }
+
+      // do not LIMIT the main result for ranking; restrict row keys via CTE join instead
+      limitClause = '';
+
+      if (dimsForHaving.length > 0) {
+        const rowDims = BaseUtilities.buildDimensionReference(this.options.rows, this.options);
+        if (rowDims.length > 0) {
+          const isLeafAllDims = dimsForHaving.map((d) => `GROUPING(${d}) = 0`).join(' AND ');
+          const isRowGrand = rowDims.map((d) => `GROUPING(${d}) = 1`).join(' AND ');
+          const allowLeafOrRowGrand = `(${isLeafAllDims}) OR (${isRowGrand})`;
+          havingConditions.push(allowLeafOrRowGrand);
+        }
+      }
+
+      const rankingWhere = this.buildRankingKeysWhereClause();
+      if (rankingWhere) {
+        whereConditions.push(rankingWhere);
+      }
+    }
+
+    return this.buildCompleteQuery({
+      select: this.buildSelectClause(selectItems),
+      from: this.buildFromWithJoins(),
+      where: this.buildWhereClause(
+        [this.paginationBuilder.buildAdditionalWhere(), ...whereConditions].filter(Boolean),
+      ),
+      groupBy: groupByColumns.length > 0 ? this.buildGroupByClause(groupByColumns) : undefined,
+      having: this.buildHavingClause(havingConditions),
+      orderBy: orderByClause,
+      limit: limitClause,
+    });
+  }
+
+  // builds select items based on dims, rollup, and measures
+  private buildSelectItems(): string[] {
+    const selectItems: string[] = [];
+
+    if (this.hasDimensions()) {
+      selectItems.push(...this.buildDimensionSelects());
+    }
+
+    if (this.shouldGenerateRollup()) {
+      selectItems.push(...this.rollupBuilder.buildRollupSelects());
+    }
+
+    if (this.hasMeasures()) {
+      selectItems.push(...this.measureBuilder.buildMeasureSelects());
+    }
+
+    return selectItems;
+  }
+
+  // prepares dimension projections respecting dot-notation mode
+  private buildDimensionSelects(): string[] {
+    const dimensions: string[] = [];
+
+    if (this.options.rows?.length) {
+      this.options.rows.forEach((row) => {
+        const column = BaseUtilities.formatColumnReferenceForDb(row, this.options);
+        dimensions.push(`${column} AS "${row.id}"`);
+      });
+    }
+
+    if (this.options.columns?.length) {
+      this.options.columns.forEach((col) => {
+        const column = BaseUtilities.formatColumnReferenceForDb(col, this.options);
+        dimensions.push(`${column} AS "${col.id}"`);
+      });
+    }
+
+    return dimensions;
+  }
+
+  // decides group by list based on rollup and measures
+  private buildGroupByColumns(): string[] {
+    if (!this.hasMeasures() && !this.shouldGenerateRollup()) {
+      return [];
+    }
+
+    if (this.shouldGenerateRollup()) {
+      return this.rollupBuilder.buildGroupByClause().replace('GROUP BY ', '').split(', ');
+    }
+
+    return BaseUtilities.extractDimensionsFromOptions(this.options);
+  }
+
+  // checks if dims, cols, filters span multiple tables
+  private containsDifferentTables(): boolean {
+    const tables = new Set<string>();
+    const originalParentTables = new Set<string>();
+
+    [...(this.options.rows || []), ...(this.options.columns || [])].forEach((item) => {
+      if (!item) return;
+
+      const directTableName = item.tableName;
+      const inferredTableName =
+        !directTableName && item.id ? BaseUtilities.getTableNameFromId(item.id) : null;
+      const effectiveTableName = directTableName || inferredTableName;
+
+      if (effectiveTableName) {
+        tables.add(effectiveTableName);
+
+        if (item.type === 'Resolved' && item.orderByRef) {
+          originalParentTables.add(item.orderByRef);
+        }
+      }
+    });
+
+    (this.options.values || []).forEach((measure) => {
+      if (!measure) return;
+
+      const directTableName = measure.tableName;
+      const inferredTableName =
+        !directTableName && measure.id ? BaseUtilities.getTableNameFromId(measure.id) : null;
+      const effectiveTableName = directTableName || inferredTableName;
+
+      if (effectiveTableName) {
+        tables.add(effectiveTableName);
+      }
+    });
+
+    if (this.options.superFilters?.children) {
+      this.extractFilterTables(this.options.superFilters.children, tables);
+    }
+
+    const totalUniqueTables = new Set([...tables, ...originalParentTables]);
+    return totalUniqueTables.size > 1;
+  }
+
+  // traverses filter tree collecting table names
+  private extractFilterTables(children: SuperFilterChild[], tables: Set<string>): void {
+    children.forEach((child) => {
+      if (child.filters?.tableNames) {
+        child.filters.tableNames.forEach((tableName: string) => {
+          if (tableName) tables.add(tableName);
+        });
+      }
+      if (child.children) {
+        this.extractFilterTables(child.children, tables);
+      }
+    });
+  }
+
+  private hasMeasureInValues(): boolean {
+    return (this.options.values || []).some((measure) => measure.type?.toUpperCase() === 'MEASURE');
+  }
+
+  private hasFiltersForTable(tableName: string): boolean {
+    if (!this.options.superFilters?.children) return false;
+
+    return this.checkFiltersForTable(this.options.superFilters.children, tableName);
+  }
+
+  private checkFiltersForTable(children: SuperFilterChild[], tableName: string): boolean {
+    return children.some((child) => {
+      if (child.filters?.tableNames?.includes(tableName)) {
+        return true;
+      }
+      if (child.children) {
+        return this.checkFiltersForTable(child.children, tableName);
+      }
+      return false;
+    });
+  }
+
+  private hasMeasuresForTable(tableName: string): boolean {
+    return (this.options.values || []).some((measure) => measure.tableName === tableName);
+  }
+
+  // builds distinct projection for dims path
+  private buildDistinctQuery(tableName: string, dimensions: string[], whereClause: string): string {
+    const fromClause = this.buildFromWithJoins();
+
+    if (dimensions.length === 0) {
+      return `SELECT COUNT(*) ${fromClause}`;
+    }
+
+    const selectDims = this.buildDimensionSelects();
+    let query = `SELECT DISTINCT ${selectDims.join(', ')} ${fromClause}`;
+
+    if (whereClause) {
+      query += ` WHERE ${whereClause}`;
+    }
+
+    const orderByClause = this.orderBuilder.buildOrderByClause();
+    if (orderByClause) {
+      query += ` ${orderByClause}`;
+    } else if (dimensions.length > 0) {
+      query += ` ORDER BY ${dimensions[0]} ASC`;
+    }
+
+    return query;
+  }
+
+  private hasRankingFilters(): boolean {
+    if (!this.options.superFilters?.children) return false;
+    return this.findFirstRankingConfig(this.options.superFilters.children) !== null;
+  }
+
+  // finds the first ranking config to override order and limit
+  private findFirstRankingConfig(children: SuperFilterChild[]): RankingConfig | null {
+    for (const child of children) {
+      const filters = child.filters as unknown as {
+        rankingFilter?: RankingConfig[];
+        filterType?: string;
+      };
+      if (
+        filters &&
+        filters.filterType === 'RANKING' &&
+        Array.isArray(filters.rankingFilter) &&
+        filters.rankingFilter.length > 0
+      ) {
+        return filters.rankingFilter[0];
+      }
+      if (child.children) {
+        const found = this.findFirstRankingConfig(child.children);
+        if (found) return found;
+      }
+    }
+    return null;
+  }
+
+  // generates union/intersect queries for top/bottom selection across rules
+  private buildTopNRankingQuery(tableName: string, dimensions: string[]): string {
+    const rankings = this.findAllRankingConfigs(this.options.superFilters?.children || []);
+    if (rankings.length === 0) {
+      return this.buildDistinctQuery(tableName, dimensions, '');
+    }
+
+    const formattedTableName = BaseUtilities.formatTableNameForDb(
+      tableName,
+      this.options.databaseDetails?.databaseType as string,
+    );
+    // if no dimensions, rank rows by the measure column value directly
+    if (dimensions.length === 0) {
+      const rk = rankings[0];
+      const direction = rk.type === 'BOTTOM' ? 'ASC' : 'DESC';
+
+      const actualId = BaseUtilities.extractColumnIdFromHierarchy(
+        rk.rankByColumnId || `${rk.rankByTableName || ''}[${rk.rankByColumnName || ''}]`,
+      );
+
+      const isBlend = BaseUtilities.getSource(this.options) === SOURCE_TYPES.BLEND;
+      const tableNameForRef = tableName;
+      const aggTypeUpper = (rk.rankByAggregationType || 'SUM').toUpperCase();
+      const aggPrefix = aggTypeUpper;
+
+      const blendMeasureRef = BaseUtilities.formatTableColumnReference(
+        tableNameForRef,
+        `${aggPrefix}__${actualId}`,
+      );
+
+      let rkRef: string;
+      if (isBlend) {
+        rkRef = blendMeasureRef;
+      } else if (this.options.databaseDetails?.databaseType === 'duckdb') {
+        rkRef = `"${actualId}"`;
+      } else {
+        const tableRef = rk.rankByTableName || BaseUtilities.getDefaultTableName(this.options);
+        rkRef = `${tableRef}.${rk.rankByColumnName}`;
+      }
+
+      if (rk.isPercentage) {
+        const percentile = Math.max(0, Math.min(100, rk.value)) / 100;
+        return [
+          'SELECT * FROM (',
+          `SELECT *, PERCENT_RANK() OVER (ORDER BY ${rkRef} ${direction}) AS __pr`,
+          `FROM ${formattedTableName}`,
+          `) __ranked WHERE __pr <= ${percentile}`,
+        ].join('\n');
+      }
+
+      const limit = Math.max(1, Math.floor(rk.value));
+      return `SELECT * FROM ${formattedTableName} ORDER BY ${rkRef} ${direction} LIMIT ${limit}`;
+    }
+
+    const fromClause = `FROM ${formattedTableName}`;
+    const groupByClause = `GROUP BY ${dimensions.join(', ')}`;
+
+    const subqueries: string[] = [];
+    rankings.forEach((rk) => {
+      const agg = BaseUtilities.mapAggregationType(rk.rankByAggregationType || 'SUM');
+      const isBlend = BaseUtilities.getSource(this.options) === SOURCE_TYPES.BLEND;
+      const actualId = BaseUtilities.extractColumnIdFromHierarchy(
+        rk.rankByColumnId || `${rk.rankByTableName || ''}[${rk.rankByColumnName || ''}]`,
+      );
+      let rkRef: string;
+      let selectClause: string;
+
+      if (isBlend) {
+        const aggTypeUpper = (rk.rankByAggregationType || 'SUM').toUpperCase();
+        const aggPrefix = aggTypeUpper; // For BLEND, alias prefix must match input aggregation type
+        const measureAlias = `${aggPrefix}__${actualId}`;
+        const measureRef = BaseUtilities.formatTableColumnReference(tableName, measureAlias);
+        rkRef = measureRef;
+        selectClause = `SELECT ${dimensions.join(', ')}, ${agg}("${measureAlias}") AS "${measureAlias}", COUNT(*) OVER () AS "[TotalRowsCountForResult]"`;
+      } else if (this.options.databaseDetails?.databaseType === 'duckdb') {
+        rkRef = `"${actualId}"`;
+        selectClause = `SELECT ${dimensions.join(', ')}, ${agg}(${rkRef}), COUNT(*) OVER () AS "[TotalRowsCountForResult]"`;
+      } else {
+        const tableRef = rk.rankByTableName || BaseUtilities.getDefaultTableName(this.options);
+        rkRef = `${tableRef}.${rk.rankByColumnName}`;
+        selectClause = `SELECT ${dimensions.join(', ')}, ${agg}(${rkRef}), COUNT(*) OVER () AS "[TotalRowsCountForResult]"`;
+      }
+
+      if (rk.type === 'BOTH') {
+        const topN = Math.ceil(rk.value);
+        const bottomN = Math.floor(rk.value);
+        subqueries.push(
+          [
+            selectClause,
+            fromClause,
+            groupByClause,
+            `ORDER BY ${agg}(${rkRef}) DESC`,
+            `LIMIT ${topN}`,
+          ].join('\n'),
+        );
+        subqueries.push(
+          [
+            selectClause,
+            fromClause,
+            groupByClause,
+            `ORDER BY ${agg}(${rkRef}) ASC`,
+            `LIMIT ${bottomN}`,
+          ].join('\n'),
+        );
+      } else {
+        const dir = rk.type === 'TOP' ? 'DESC' : 'ASC';
+        subqueries.push(
+          [
+            selectClause,
+            fromClause,
+            groupByClause,
+            isBlend
+              ? `ORDER BY "${(rk.rankByAggregationType || 'SUM').toUpperCase()}__${actualId}" ${dir}`
+              : `ORDER BY ${agg}(${rkRef}) ${dir}`,
+            `LIMIT ${rk.value}`,
+          ].join('\n'),
+        );
+      }
+    });
+
+    const logicalOp = this.extractRankingLogicalOperator(this.options.superFilters?.children || []);
+    if (logicalOp === 'INTERSECT') {
+      return subqueries.join(' INTERSECT ');
+    }
+    return subqueries.join(' UNION ');
+  }
+
+  private buildRankingOrderClause(ranking: RankingConfig): string {
+    const direction = ranking.type === 'BOTTOM' ? 'ASC' : 'DESC';
+    const agg = BaseUtilities.mapAggregationType(ranking.rankByAggregationType || 'SUM');
+    const isBlend = BaseUtilities.getSource(this.options) === SOURCE_TYPES.BLEND;
+
+    if (isBlend) {
+      const actualId = BaseUtilities.extractColumnIdFromHierarchy(
+        ranking.rankByColumnId ||
+          `${ranking.rankByTableName || ''}[${ranking.rankByColumnName || ''}]`,
+      );
+      const aggTypeUpper = (ranking.rankByAggregationType || 'SUM').toUpperCase();
+      const aggPrefix = aggTypeUpper; // For BLEND, alias prefix must match input aggregation type
+      const aliasName = `${aggPrefix}__${actualId}`;
+      return `"${aliasName}" ${direction}`;
+    }
+
+    let measureRef: string;
+    if (this.options.databaseDetails?.databaseType === 'duckdb') {
+      const actualId = BaseUtilities.extractColumnIdFromHierarchy(
+        ranking.rankByColumnId ||
+          `${ranking.rankByTableName || ''}[${ranking.rankByColumnName || ''}]`,
+      );
+      measureRef = `"${actualId}"`;
+    } else {
+      const tableRef = ranking.rankByTableName || BaseUtilities.getDefaultTableName(this.options);
+      measureRef = `${tableRef}.${ranking.rankByColumnName}`;
+    }
+    return `${agg}(${measureRef}) ${direction}`;
+  }
+
+  private calculateRankingLimit(ranking: RankingConfig): number {
+    const distinctCount = ranking.isPercentage ? this.estimateDistinctCountForRanking() : 0;
+    if (ranking.isPercentage && distinctCount > 0) {
+      return Math.max(1, Math.floor((ranking.value * distinctCount) / 100));
+    }
+    return ranking.value;
+  }
+
+  private estimateDistinctCountForRanking(): number {
+    const dims = BaseUtilities.extractDimensionsFromOptions(this.options);
+    return Math.max(0, dims.length > 0 ? 1000000 : 0);
+  }
+
+  private findAllRankingConfigs(children: SuperFilterChild[]): RankingConfig[] {
+    const result: RankingConfig[] = [];
+    for (const child of children) {
+      if (child.filters?.rankingFilter && Array.isArray(child.filters.rankingFilter)) {
+        result.push(...child.filters.rankingFilter);
+      }
+      if (child.children) {
+        result.push(...this.findAllRankingConfigs(child.children));
+      }
+    }
+    return result;
+  }
+
+  private extractRankingLogicalOperator(children: SuperFilterChild[]): string {
+    for (const child of children) {
+      if (child.filters?.logicalOperator) {
+        return child.filters.logicalOperator.toUpperCase();
+      }
+      if (child.children) {
+        const v = this.extractRankingLogicalOperator(child.children);
+        if (v) return v;
+      }
+    }
+    return 'UNION';
+  }
+
+  private buildSimpleAggregateQuery(
+    tableName: string,
+    dimensions: string[],
+    whereClause: string,
+  ): string {
+    const measures = this.extractMeasures();
+    const selectParts = [...this.buildDimensionSelects()];
+
+    measures.forEach((measure) => {
+      if (measure.type?.toLowerCase() === 'measure') {
+        selectParts.push(`"${measure.id}" AS "${measure.label}"`);
+      } else {
+        const aggregationType = BaseUtilities.mapAggregationType(measure.aggregationType || 'SUM');
+        selectParts.push(`${aggregationType}("${measure.id}") AS "${measure.label}"`);
+      }
+    });
+
+    const fromClause = this.buildFromWithJoins();
+    let query = `SELECT ${selectParts.join(', ')} ${fromClause}`;
+
+    if (whereClause) {
+      query += ` WHERE ${whereClause}`;
+    }
+
+    if (dimensions.length > 0) {
+      query += ` GROUP BY ${dimensions.join(', ')}`;
+      query += ` ORDER BY ${dimensions.map((_, index) => `${index + 1}`).join(', ')}`;
+    }
+
+    return query;
+  }
+
+  private isSelectAllRequested(): boolean {
+    const sc = this.options.selectedColumns || [];
+    if (Array.isArray(sc) && sc.some((c) => c === '*')) return true;
+    if (this.options.rows?.length === 1 && this.options.rows[0].columnName === '*') return true;
+    return false;
+  }
+
+  private buildSelectAllQuery(tableName: string, whereClause: string): string {
+    const fromClause = this.buildFromWithJoins();
+
+    const selectKeyword = this.options.distinct ? 'SELECT DISTINCT' : 'SELECT';
+    let query = `${selectKeyword} * ${fromClause}`;
+    if (whereClause) {
+      query += ` WHERE ${whereClause}`;
+    }
+
+    const orderByClause = this.orderBuilder.buildOrderByClause();
+    if (orderByClause) {
+      query += ` ${orderByClause}`;
+    }
+
+    const limitClause = this.paginationBuilder.buildLimitClause();
+    if (limitClause) {
+      query += ` ${limitClause}`;
+    }
+
+    return query;
+  }
+
+  private hasMeasureFilters(): boolean {
+    return Boolean(
+      this.options.superFilters?.children?.some(
+        (child) =>
+          child.filters &&
+          (child.filters.filterType === 'MEASURE' ||
+            child.filters.columnType?.some((type) => type?.toUpperCase() === 'MEASURE')),
+      ),
+    );
+  }
+
+  protected formatColumnReference(config: RowColumnConfig): string {
+    if (this.options.databaseDetails?.databaseType === 'duckdb') {
+      const actualColumnId = BaseUtilities.extractColumnIdFromHierarchy(config.id);
+      return `"${actualColumnId}"`;
+    }
+    return super.formatColumnReference(config);
+  }
+
+  protected buildFromClause(tableName: string, joins?: string[]): string {
+    const formattedTableName = BaseUtilities.formatTableNameForDb(
+      tableName,
+      this.options.databaseDetails?.databaseType as string,
+    );
+    let fromClause = `FROM ${formattedTableName}`;
+
+    if (joins?.length) {
+      fromClause += ` ${joins.join(' ')}`;
+    }
+
+    return fromClause;
+  }
+
+  private buildFromWithJoins(): string {
+    const plan = resolveJoinPlan(this.options);
+    const joins = DuckDbJoinBuilder.buildJoinClauses(
+      plan,
+      this.options.databaseDetails?.databaseType as string,
+      this.options,
+    );
+    return this.buildFromClause(plan.baseTable || this.getDefaultTableName(), joins);
+  }
+
+  private buildRankingKeysCTE(): string {
+    const ranking = this.findFirstRankingConfig(this.options.superFilters?.children || []);
+    if (!ranking) return '';
+    const targetDims = this.getRankingTargetDimensions();
+    if (targetDims.length === 0) return '';
+
+    const isBlend = BaseUtilities.getSource(this.options) === SOURCE_TYPES.BLEND;
+    const tableName = this.getDefaultTableName();
+    const formattedTableName = BaseUtilities.formatTableNameForDb(
+      tableName,
+      this.options.databaseDetails?.databaseType as string,
+    );
+    const direction = ranking.type === 'BOTTOM' ? 'ASC' : 'DESC';
+    const agg = BaseUtilities.mapAggregationType(ranking.rankByAggregationType || 'SUM');
+
+    let measureExpr: string;
+    if (isBlend) {
+      const actualId = BaseUtilities.extractColumnIdFromHierarchy(
+        ranking.rankByColumnId ||
+          `${ranking.rankByTableName || ''}[${ranking.rankByColumnName || ''}]`,
+      );
+      const aggTypeUpper = (ranking.rankByAggregationType || 'SUM').toUpperCase();
+      const aliasName = `${aggTypeUpper}__${actualId}`;
+      measureExpr = `${agg}("${aliasName}")`;
+    } else if (this.options.databaseDetails?.databaseType === 'duckdb') {
+      const actualId = BaseUtilities.extractColumnIdFromHierarchy(
+        ranking.rankByColumnId ||
+          `${ranking.rankByTableName || ''}[${ranking.rankByColumnName || ''}]`,
+      );
+      measureExpr = `${agg}("${actualId}")`;
+    } else {
+      const tableRef = ranking.rankByTableName || BaseUtilities.getDefaultTableName(this.options);
+      measureExpr = `${agg}(${tableRef}.${ranking.rankByColumnName})`;
+    }
+
+    const dimAliases = targetDims.map((_, idx) => `__rk_dim${idx + 1}`);
+    const selectDims = targetDims.map((d, idx) => `${d} AS ${dimAliases[idx]}`).join(', ');
+    const groupByDims = targetDims.join(', ');
+
+    return [
+      `__ranking_keys AS (`,
+      `  SELECT ${selectDims}, ${measureExpr} AS __rk_value`,
+      `  FROM ${formattedTableName}`,
+      `  GROUP BY ${groupByDims}`,
+      `  ORDER BY __rk_value ${direction}`,
+      `  LIMIT ${this.calculateRankingLimit(ranking)}`,
+      `)`,
+    ].join('\n');
+  }
+
+  private buildRankingKeysWhereClause(): string {
+    const targetDims = this.getRankingTargetDimensions();
+    if (targetDims.length === 0) return '';
+    const comparisons = targetDims.map((d, idx) => `${d} = rk.__rk_dim${idx + 1}`).join(' AND ');
+    return `EXISTS (SELECT 1 FROM __ranking_keys rk WHERE ${comparisons})`;
+  }
+
+  private getRankingTargetDimensions(): string[] {
+    const ids = this.findFirstRankingTargetColumnIds(this.options.superFilters?.children || []);
+    if (ids.length === 0) {
+      const rowDims = BaseUtilities.buildDimensionReference(this.options.rows, this.options);
+      if (rowDims.length > 0) return rowDims;
+      return BaseUtilities.buildDimensionReference(this.options.columns, this.options);
+    }
+
+    const refs: string[] = [];
+    const findConfigById = (id: string) => {
+      const inRows = (this.options.rows || []).find((r) => r.id === id);
+      if (inRows) return inRows;
+      const inCols = (this.options.columns || []).find((c) => c.id === id);
+      if (inCols) return inCols;
+      return {
+        id,
+        tableName: BaseUtilities.getDefaultTableNameFromOptions(this.options),
+      } as unknown as RowColumnConfig;
+    };
+    ids.forEach((id) => {
+      const cfg = findConfigById(id);
+      refs.push(BaseUtilities.formatColumnReferenceForDb(cfg, this.options));
+    });
+    return refs;
+  }
+
+  private findFirstRankingTargetColumnIds(children: SuperFilterChild[]): string[] {
+    for (const child of children) {
+      const filters = child.filters as unknown as {
+        filterType?: string;
+        columnIds?: string[];
+        rankingFilter?: RankingConfig[];
+      };
+      if (filters && filters.filterType === 'RANKING' && Array.isArray(filters.rankingFilter)) {
+        return (filters.columnIds || []).filter(Boolean) as string[];
+      }
+      if (child.children) {
+        const found = this.findFirstRankingTargetColumnIds(child.children);
+        if (found.length > 0) return found;
+      }
+    }
+    return [];
+  }
+}