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

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

@@ -0,0 +1,228 @@
+import { BaseOrderBuilder } from '@epm-query-builder/base/BaseOrderBuilder';
+import { OrderByConfig, RowColumnConfig } from '@epm-query-builder/types/query-builder-types';
+import { BaseUtilities } from '@epm-query-builder/base/BaseUtilities';
+
+export class DuckDbOrderBuilder extends BaseOrderBuilder {
+  buildOrderByClause(): string {
+    const orderByClauses = this.buildDuckDbOrderByClauses();
+
+    if (orderByClauses.length === 0) {
+      return '';
+    }
+
+    return `ORDER BY ${orderByClauses.join(', ')}`;
+  }
+
+  private buildDuckDbOrderByClauses(): string[] {
+    const clauses: string[] = [];
+
+    if (this.hasRollupOrdering()) {
+      clauses.push(...this.buildDuckDbRollupOrderClauses());
+    }
+
+    if (this.options.orderBy?.length) {
+      clauses.push(...this.buildDuckDbCustomOrderClauses());
+    } else {
+      clauses.push(...this.buildDuckDbDefaultOrderClauses());
+    }
+
+    return clauses;
+  }
+
+  private buildDuckDbCustomOrderClauses(): string[] {
+    if (!this.options.orderBy?.length) {
+      return [];
+    }
+
+    return this.options.orderBy.map((orderBy) => {
+      const column = this.resolveDuckDbOrderByColumn(orderBy);
+      const direction = this.mapSortDirection(orderBy.type);
+      const nullsHandling = this.buildDuckDbNullsHandling(direction);
+
+      const isMonth =
+        (orderBy.columnName || '').toLowerCase().includes('month') ||
+        (orderBy.id || '').toLowerCase().includes('month');
+      const isQuarter =
+        (orderBy.columnName || '').toLowerCase().includes('quarter') ||
+        (orderBy.id || '').toLowerCase().includes('quarter');
+
+      if (isMonth) {
+        const monthOrder = BaseUtilities.buildMonthOrderKey(column);
+        return `${monthOrder} ${direction}${nullsHandling}`;
+      }
+      if (isQuarter) {
+        const quarterOrder = BaseUtilities.buildQuarterOrderKey(column);
+        return `${quarterOrder} ${direction}${nullsHandling}`;
+      }
+
+      return `${column} ${direction}${nullsHandling}`;
+    });
+  }
+
+  private buildDuckDbDefaultOrderClauses(): string[] {
+    const clauses: string[] = [];
+
+    if (this.options.rows?.length) {
+      this.options.rows.forEach((row) => {
+        const useDot = BaseUtilities.shouldUseDotNotation(this.options);
+        const column = useDot
+          ? this.formatDuckDbOrderByColumn(row)
+          : `"${BaseUtilities.extractColumnIdFromHierarchy(row.id)}"`;
+        const nullsHandling = this.buildDuckDbNullsHandling('ASC');
+        const isMonth =
+          (row.columnName || '').toLowerCase().includes('month') ||
+          (row.label || '').toLowerCase().includes('month');
+        const isQuarter =
+          (row.columnName || '').toLowerCase().includes('quarter') ||
+          (row.label || '').toLowerCase().includes('quarter');
+        if (isMonth) {
+          const monthOrder = BaseUtilities.buildMonthOrderKey(column);
+          clauses.push(`${monthOrder} ASC${nullsHandling}`);
+        } else if (isQuarter) {
+          const quarterOrder = BaseUtilities.buildQuarterOrderKey(column);
+          clauses.push(`${quarterOrder} ASC${nullsHandling}`);
+        } else {
+          clauses.push(`${column} ASC${nullsHandling}`);
+        }
+      });
+    }
+
+    if (this.options.columns?.length) {
+      this.options.columns.forEach((col) => {
+        const useDot = BaseUtilities.shouldUseDotNotation(this.options);
+        const column = useDot
+          ? this.formatDuckDbOrderByColumn(col)
+          : `"${BaseUtilities.extractColumnIdFromHierarchy(col.id)}"`;
+        const nullsHandling = this.buildDuckDbNullsHandling('ASC');
+        const isMonth =
+          (col.columnName || '').toLowerCase().includes('month') ||
+          (col.label || '').toLowerCase().includes('month');
+        const isQuarter =
+          (col.columnName || '').toLowerCase().includes('quarter') ||
+          (col.label || '').toLowerCase().includes('quarter');
+        if (isMonth) {
+          const monthOrder = BaseUtilities.buildMonthOrderKey(column);
+          clauses.push(`${monthOrder} ASC${nullsHandling}`);
+        } else if (isQuarter) {
+          const quarterOrder = BaseUtilities.buildQuarterOrderKey(column);
+          clauses.push(`${quarterOrder} ASC${nullsHandling}`);
+        } else {
+          clauses.push(`${column} ASC${nullsHandling}`);
+        }
+      });
+    }
+
+    return clauses;
+  }
+
+  private buildDuckDbRollupOrderClauses(): string[] {
+    const clauses: string[] = [];
+
+    if (this.options.rows?.length && !this.options.skipRollup) {
+      clauses.push('"[IsRowGrandTotal]" DESC NULLS LAST');
+
+      const rowCount = this.options.rows.length;
+      for (let i = 1; i < rowCount; i++) {
+        clauses.push(`"[IsDM${i - 1}Total]" DESC NULLS LAST`);
+      }
+    }
+
+    if (this.options.columns?.length && !this.options.skipRollup) {
+      clauses.push('"[IsColumnGrandTotal]" DESC NULLS LAST');
+
+      const rowCount = this.options.rows?.length || 0;
+      const columnCount = this.options.columns.length;
+      for (let i = 1; i < columnCount; i++) {
+        clauses.push(`"[IsDM${rowCount + i - 1}Total]" DESC NULLS LAST`);
+      }
+    }
+
+    return clauses;
+  }
+
+  private getRollupColumnPosition(columnName: string): number {
+    let position = 1;
+
+    if (this.options.rows?.length) {
+      position += this.options.rows.length;
+    }
+
+    if (this.options.columns?.length) {
+      position += this.options.columns.length;
+    }
+
+    if (this.options.values?.length) {
+      position += this.options.values.length;
+    }
+
+    position += 1;
+
+    if (columnName.includes('IsRowGrandTotal')) {
+      return position + 2;
+    } else if (columnName.includes('IsColumnGrandTotal')) {
+      return position + 3;
+    } else {
+      return position + 4;
+    }
+  }
+
+  private resolveDuckDbOrderByColumn(orderBy: OrderByConfig): string {
+    if (orderBy.isColumnPresentInOutput) {
+      if (orderBy.aggregationType) {
+        return `"${orderBy.aggregationType}__${orderBy.tableName}[${orderBy.columnName}]"`;
+      }
+      return `"${orderBy.tableName}[${orderBy.columnName}]"`;
+    }
+
+    const config: RowColumnConfig = {
+      id: orderBy.id,
+      columnName: orderBy.columnName,
+      tableName: orderBy.tableName,
+      label: orderBy.id,
+      type: 'Column',
+    };
+    return BaseUtilities.formatColumnReferenceForDb(config, this.options);
+  }
+
+  private formatDuckDbOrderByColumn(config: RowColumnConfig): string {
+    if (config.orderByRef) {
+      return BaseUtilities.formatColumnReferenceForDb(config, this.options);
+    }
+
+    return BaseUtilities.formatColumnReferenceForDb(config, this.options);
+  }
+
+  private buildDuckDbNullsHandling(direction: 'ASC' | 'DESC'): string {
+    return direction === 'DESC' ? ' NULLS LAST' : ' NULLS FIRST';
+  }
+
+  private isDateHierarchyColumn(config: RowColumnConfig): boolean {
+    const dateColumns = ['Month', 'Quarter', 'Year'];
+    return dateColumns.some((dateCol) =>
+      config.columnName?.toLowerCase().includes(dateCol.toLowerCase()),
+    );
+  }
+
+  private getDuckDbDateColumnName(columnName: string): string {
+    const dateColumnMap: Record<string, string> = {
+      Month: 'MonthNo',
+      Quarter: 'QuarterNo',
+      Year: 'Year',
+    };
+
+    for (const [key, value] of Object.entries(dateColumnMap)) {
+      if (columnName.toLowerCase().includes(key.toLowerCase())) {
+        return value;
+      }
+    }
+
+    return columnName;
+  }
+
+  protected hasRollupOrdering(): boolean {
+    return (
+      BaseUtilities.shouldGenerateRollupForOptions(this.options) &&
+      BaseUtilities.hasMeasuresInOptions(this.options)
+    );
+  }
+}

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

@@ -0,0 +1,186 @@
+import { BasePaginationBuilder } from '@epm-query-builder/base/BasePaginationBuilder';
+import { PaginationConfig } from '@epm-query-builder/types/query-builder-types';
+import { PaginationError } from '@epm-query-builder/errors/QueryBuilderErrors';
+import { BaseUtilities } from '@epm-query-builder/base/BaseUtilities';
+
+export class DuckDbPaginationBuilder extends BasePaginationBuilder {
+  buildLimitClause(): string {
+    if (!this.options.pagination) {
+      return '';
+    }
+
+    const { skip = 0, limit } = this.options.pagination;
+
+    if (limit === undefined || limit <= 0) {
+      return '';
+    }
+
+    if (skip > 0) {
+      return `LIMIT ${limit} OFFSET ${skip}`;
+    }
+
+    return `LIMIT ${limit}`;
+  }
+
+  buildOffsetClause(): string {
+    if (!this.options.pagination?.skip) {
+      return '';
+    }
+
+    return `OFFSET ${this.options.pagination.skip}`;
+  }
+
+  buildAdditionalWhere(): string {
+    const reference = this.options.pagination?.reference;
+
+    if (!reference || !reference.command) return '';
+
+    switch (reference.command) {
+      case 'NEXT_HEIR':
+        return this.buildNextHeirWhere(reference);
+      case 'SIBLING':
+        return this.buildSiblingWhere(reference);
+      case 'CHILDREN':
+        return this.buildChildrenWhere(reference);
+      default:
+        return '';
+    }
+  }
+
+  private buildNextHeirWhere(reference: PaginationConfig['reference']): string {
+    if (!reference?.dimensions?.length || !reference.nextToken?.length) {
+      return '';
+    }
+
+    if (reference.dimensions.length !== reference.nextToken.length) {
+      throw new PaginationError(
+        'NEXT_HEIR',
+        'dimensions and nextToken arrays must have the same length',
+      );
+    }
+
+    const conditions = reference.dimensions
+      .map((dim, index) => {
+        const tokenValue = reference.nextToken?.[index];
+        if (!tokenValue) return null;
+
+        const operator = this.getHierarchicalOperator(index, reference.dimensions!.length);
+        return `${BaseUtilities.sanitizeIdentifierString(dim)} ${operator} '${tokenValue}'`;
+      })
+      .filter((condition): condition is string => Boolean(condition));
+
+    if (conditions.length === 0) {
+      throw new PaginationError(
+        'NEXT_HEIR',
+        'no valid conditions generated from dimensions and nextToken',
+      );
+    }
+
+    const hierarchicalCondition = this.buildHierarchicalCondition(conditions);
+    return hierarchicalCondition;
+  }
+
+  private buildSiblingWhere(reference: PaginationConfig['reference']): string {
+    if (!reference?.dimensions?.length || !reference.instances?.length) {
+      return '';
+    }
+
+    if (reference.dimensions.length === 0 || reference.instances.length === 0) {
+      throw new PaginationError('SIBLING', 'dimensions and instances cannot be empty');
+    }
+
+    const parentConditions: string[] = [];
+    const siblingConditions: string[] = [];
+
+    reference.dimensions.forEach((dim, index) => {
+      const instanceValue = reference.instances?.[index];
+      if (instanceValue && index < reference.dimensions!.length - 1) {
+        parentConditions.push(
+          `${BaseUtilities.sanitizeIdentifierString(dim)} = '${instanceValue}'`,
+        );
+      } else if (instanceValue && index === reference.dimensions!.length - 1) {
+        siblingConditions.push(
+          `${BaseUtilities.sanitizeIdentifierString(dim)} != '${instanceValue}'`,
+        );
+      }
+    });
+
+    const allConditions = [...parentConditions, ...siblingConditions];
+
+    if (allConditions.length === 0) {
+      throw new PaginationError('SIBLING', 'no valid conditions generated');
+    }
+
+    return BaseUtilities.combineConditions(allConditions, 'AND');
+  }
+
+  private buildChildrenWhere(reference: PaginationConfig['reference']): string {
+    if (!reference?.dimensions || !reference.instances) {
+      return '';
+    }
+
+    const parentConditions = reference.dimensions
+      .slice(0, -1)
+      .map((dim, index) => {
+        const instanceValue = reference.instances?.[index];
+        return instanceValue ? `${dim} = '${instanceValue}'` : null;
+      })
+      .filter(Boolean);
+
+    if (parentConditions.length === 0) {
+      return '';
+    }
+
+    return parentConditions.join(' AND ');
+  }
+
+  buildPaginationCTE(): string {
+    if (!this.options.pagination?.reference?.command) {
+      return '';
+    }
+
+    const { reference } = this.options.pagination;
+
+    if (!reference.dimensions) {
+      return '';
+    }
+
+    return `pagination_context AS (
+            SELECT ${reference.dimensions.join(', ')}
+            FROM (VALUES ${this.buildPaginationValues(reference)}) AS context(${reference.dimensions.join(', ')})
+        )`;
+  }
+
+  private buildPaginationValues(reference: { instances?: string[]; nextToken?: string[] }): string {
+    if (!reference.instances || !reference.nextToken) {
+      return "('')";
+    }
+
+    const instances = reference.instances.map((val: string) => `'${val}'`).join(', ');
+    const tokens = reference.nextToken.map((val: string) => `'${val}'`).join(', ');
+
+    return `(${instances}), (${tokens})`;
+  }
+
+  private getHierarchicalOperator(index: number, totalLevels: number): string {
+    if (index < totalLevels - 1) {
+      return '>=';
+    }
+    return '>';
+  }
+
+  private buildHierarchicalCondition(conditions: string[]): string {
+    if (conditions.length === 1) {
+      return conditions[0];
+    }
+
+    const primaryCondition = conditions[0];
+    const secondaryConditions = conditions.slice(1);
+
+    if (secondaryConditions.length === 0) {
+      return primaryCondition;
+    }
+
+    return `(${primaryCondition} OR (${secondaryConditions.join(' OR ')}))`;
+  }
+}