@finos/legend-query-builder 4.14.21 → 4.14.22

package/src/components/result/QueryBuilderResultPanel.tsx

@@ -288,6 +288,7 @@ export const QueryBuilderResultPanel = observer(
       } else {
         queryBuilderState.resultState.setPreviewLimit(previewLimitValue);
       }
+      queryBuilderState.resultState.updatePreviewLimitInConfig();
     };
 
     const onKeyDown: React.KeyboardEventHandler<HTMLInputElement> = (event) => {

package/src/components/result/tds/QueryBuilderTDSGridResult.tsx

@@ -241,6 +241,7 @@ export const QueryBuilderTDSGridResult = observer(
         columns: columnAPi.getColumnState(),
         isPivotModeEnabled: columnAPi.isPivotMode(),
         isLocalModeEnabled: true,
+        previewLimit: resultState.previewLimit,
       });
     };
 

package/src/stores/QueryBuilderResultState.ts

@@ -82,6 +82,7 @@ type QueryBuilderDataGridConfig = {
   columns: DataGridColumnState[];
   isPivotModeEnabled: boolean | undefined;
   isLocalModeEnabled: boolean | undefined;
+  previewLimit?: number | undefined;
 };
 
 export class QueryBuilderResultState {
@@ -131,6 +132,7 @@ export class QueryBuilderResultState {
       setQueryRunPromise: action,
       setIsQueryUsageViewerOpened: action,
       handlePreConfiguredGridConfig: action,
+      updatePreviewLimitInConfig: action,
       exportData: flow,
       runQuery: flow,
       cancelQuery: flow,
@@ -191,21 +193,28 @@ export class QueryBuilderResultState {
     this.isQueryUsageViewerOpened = val;
   }
 
+  updatePreviewLimitInConfig(): void {
+    if (this.gridConfig) {
+      this.gridConfig.previewLimit = this.previewLimit;
+    }
+  }
+
   handlePreConfiguredGridConfig(config: QueryGridConfig): void {
     const newConfig = {
+      ...config,
       columns: config.columns as DataGridColumnState[],
-      isPivotModeEnabled: Boolean(config.isPivotModeEnabled),
-      isLocalModeEnabled: Boolean(config.isLocalModeEnabled),
     };
+    if (config.previewLimit) {
+      this.setPreviewLimit(config.previewLimit);
+    }
     this.setGridConfig(newConfig);
   }
 
   getQueryGridConfig(): QueryGridConfig | undefined {
     if (this.gridConfig) {
       return {
+        ...this.gridConfig,
         columns: this.gridConfig.columns as object[],
-        isPivotModeEnabled: Boolean(this.gridConfig.isPivotModeEnabled),
-        isLocalModeEnabled: Boolean(this.gridConfig.isLocalModeEnabled),
       };
     }
     return undefined;

package/src/stores/QueryBuilderStateHashUtils.ts

@@ -71,7 +71,7 @@ export enum QUERY_BUILDER_STATE_HASH_STRUCTURE {
   // OLAPGroup state
   TDS_WINDOW_GROUPBY_STATE = 'TDS_WINDOW_STATE',
   TDS_WINDOW_GROUPBY_OPERATION_STATE = 'TDS_WINDOW_OPERATION_STATE',
-  TDS_WINDOW_GROUPBY_AGG_OPERATION_STATE = 'TDS_WINDOW_AGG_OPERATION_STATE',
+  TDS_WINDOW_GROUPBY_AGG_OPERATOR_STATE = 'TDS_WINDOW_AGG_OPERATOR_STATE',
   TDS_WINDOW_COLUMN_STATE = 'TDS_WINDOW_COLUMN_STATE',
   TDS_WINDOW_COLUMN_SORTBY_STATE = 'TDS_WINDOW_COLUMN_SORTBY_STATE',
   TDS_WINDOW_OPERATOR_RANK = 'TDS_WINDOW_OPERATOR_RANK',

package/src/stores/fetch-structure/tds/QueryBuilderTDSState.ts

@@ -278,6 +278,7 @@ export class QueryBuilderTDSState
 
   get fetchStructureValidationIssues(): string[] {
     const validationIssues: string[] = [];
+
     const hasInValidCalendarAggregateColumns =
       this.aggregationState.columns.some(
         (column) =>
@@ -289,6 +290,7 @@ export class QueryBuilderTDSState
         'Query has calendar function with no date column specified',
       );
     }
+
     const hasDuplicatedProjectionColumns = this.projectionColumns.some(
       (column) =>
         this.projectionColumns.filter((c) => c.columnName === column.columnName)
@@ -296,12 +298,23 @@ export class QueryBuilderTDSState
     );
     if (hasDuplicatedProjectionColumns) {
       validationIssues.push('Query has duplicated projection columns');
-      return validationIssues;
     }
-    const hasNoProjectionColumns = this.projectionColumns.length === 0;
+
+    const hasDuplicatedProjectionWindowColumns = this.projectionColumns.some(
+      (column) =>
+        this.windowState.windowColumns.filter(
+          (c) => c.columnName === column.columnName,
+        ).length > 0,
+    );
+    if (hasDuplicatedProjectionWindowColumns) {
+      validationIssues.push('Query has duplicated projection/window columns');
+    }
+
+    const hasNoProjectionColumns =
+      this.projectionColumns.length === 0 &&
+      this.queryBuilderState.changeHistoryState.canUndo;
     if (hasNoProjectionColumns) {
       validationIssues.push('Query has no projection columns');
-      return validationIssues;
     }
     return validationIssues;
   }

package/src/stores/fetch-structure/tds/window/QueryBuilderWindowState.ts

@@ -147,7 +147,7 @@ export class QueryBuilderTDS_WindowAggreationOperatorState extends QueryBuilderT
 
   override get hashCode(): string {
     return hashArray([
-      QUERY_BUILDER_STATE_HASH_STRUCTURE.TDS_WINDOW_GROUPBY_AGG_OPERATION_STATE,
+      QUERY_BUILDER_STATE_HASH_STRUCTURE.TDS_WINDOW_GROUPBY_AGG_OPERATOR_STATE,
       this.lambdaParameterName,
       this.operator,
       this.columnState.columnName,
@@ -162,21 +162,21 @@ export class QueryBuilderWindowColumnState
   readonly windowState: QueryBuilderWindowState;
   windowColumns: QueryBuilderTDSColumnState[] = [];
   sortByState: WindowGroupByColumnSortByState | undefined;
-  operationState: QueryBuilderTDS_WindowOperatorState;
+  operatorState: QueryBuilderTDS_WindowOperatorState;
   columnName: string;
 
   constructor(
     windowState: QueryBuilderWindowState,
     windowColumns: QueryBuilderTDSColumnState[],
     sortType: WindowGroupByColumnSortByState | undefined,
-    operationState: QueryBuilderTDS_WindowOperatorState,
+    operatorState: QueryBuilderTDS_WindowOperatorState,
     columnName: string,
   ) {
     super();
     makeObservable(this, {
       windowColumns: observable,
       sortByState: observable,
-      operationState: observable,
+      operatorState: observable,
       columnName: observable,
       setOperatorState: observable,
       setColumnName: action,
@@ -184,13 +184,14 @@ export class QueryBuilderWindowColumnState
       changeWindow: action,
       deleteWindow: action,
       addWindow: action,
+      setWindows: action,
       changeOperator: action,
       changeSortBy: action,
     });
     this.windowState = windowState;
     this.windowColumns = windowColumns;
     this.sortByState = sortType;
-    this.operationState = operationState;
+    this.operatorState = operatorState;
     this.columnName = columnName;
   }
 
@@ -211,9 +212,9 @@ export class QueryBuilderWindowColumnState
 
   get referencedTDSColumns(): QueryBuilderTDSColumnState[] {
     const operatorReference =
-      this.operationState instanceof
+      this.operatorState instanceof
       QueryBuilderTDS_WindowAggreationOperatorState
-        ? [this.operationState.columnState]
+        ? [this.operatorState.columnState]
         : [];
     const soryByReference = this.sortByState
       ? [this.sortByState.columnState]
@@ -222,7 +223,7 @@ export class QueryBuilderWindowColumnState
   }
 
   getColumnType(): Type | undefined {
-    return this.operationState.operator.getOperatorReturnType(
+    return this.operatorState.operator.getOperatorReturnType(
       this.windowState.tdsState.queryBuilderState.graphManagerState.graph,
     );
   }
@@ -232,7 +233,7 @@ export class QueryBuilderWindowColumnState
   }
 
   setOperatorState(op: QueryBuilderTDS_WindowOperatorState): void {
-    this.operationState = op;
+    this.operatorState = op;
   }
 
   setSortBy(val: WindowGroupByColumnSortByState | undefined): void {
@@ -247,6 +248,10 @@ export class QueryBuilderWindowColumnState
     addUniqueEntry(this.windowColumns, val);
   }
 
+  setWindows(val: QueryBuilderTDSColumnState[]): void {
+    this.windowColumns = val;
+  }
+
   deleteWindow(val: QueryBuilderTDSColumnState): void {
     deleteEntry(this.windowColumns, val);
   }
@@ -262,42 +267,58 @@ export class QueryBuilderWindowColumnState
     return [];
   }
 
-  changeOperator(windowOp: QueryBuilderTDS_WindowOperator): void {
-    const currentOperator = this.operationState.operator;
-    const currentAggregateColumn =
-      this.operationState instanceof
-      QueryBuilderTDS_WindowAggreationOperatorState
-        ? this.operationState.columnState
-        : undefined;
-    if (currentOperator !== windowOp) {
-      if (windowOp.isColumnAggregator()) {
+  getChangeOperatorStateAndColumnName(
+    currentOperator: QueryBuilderTDS_WindowOperator,
+    currentColumn: QueryBuilderTDSColumnState | undefined,
+    newOperator: QueryBuilderTDS_WindowOperator,
+  ):
+    | { operatorState: QueryBuilderTDS_WindowOperatorState; columnName: string }
+    | undefined {
+    if (currentOperator !== newOperator) {
+      if (newOperator.isColumnAggregator()) {
         const compatibleAggCol =
-          currentAggregateColumn &&
-          windowOp.isCompatibleWithColumn(currentAggregateColumn)
-            ? currentAggregateColumn
-            : this.possibleAggregatedColumns(windowOp)[0];
+          currentColumn && newOperator.isCompatibleWithColumn(currentColumn)
+            ? currentColumn
+            : this.possibleAggregatedColumns(newOperator)[0];
         if (compatibleAggCol) {
-          this.setOperatorState(
-            new QueryBuilderTDS_WindowAggreationOperatorState(
+          return {
+            operatorState: new QueryBuilderTDS_WindowAggreationOperatorState(
               this.windowState,
-              windowOp,
+              newOperator,
               compatibleAggCol,
             ),
-          );
-          this.setColumnName(
-            `${windowOp.getLabel()} of ${compatibleAggCol.columnName}`,
-          );
+            columnName: `${newOperator.getLabel()} of ${
+              compatibleAggCol.columnName
+            }`,
+          };
         }
       } else {
-        this.setOperatorState(
-          new QueryBuilderTDS_WindowRankOperatorState(
+        return {
+          operatorState: new QueryBuilderTDS_WindowRankOperatorState(
             this.windowState,
-            windowOp,
+            newOperator,
           ),
-        );
-        this.setColumnName(`${windowOp.getLabel()}`);
+          columnName: `${newOperator.getLabel()}`,
+        };
       }
     }
+    return undefined;
+  }
+
+  changeOperator(windowOp: QueryBuilderTDS_WindowOperator): void {
+    const stateAndName = this.getChangeOperatorStateAndColumnName(
+      this.operatorState.operator,
+      this.operatorState instanceof
+        QueryBuilderTDS_WindowAggreationOperatorState
+        ? this.operatorState.columnState
+        : undefined,
+      windowOp,
+    );
+
+    if (stateAndName) {
+      this.setOperatorState(stateAndName.operatorState);
+      this.setColumnName(stateAndName.columnName);
+    }
   }
 
   changeSortBy(sortOp: COLUMN_SORT_TYPE | undefined): void {
@@ -323,7 +344,7 @@ export class QueryBuilderWindowColumnState
       QUERY_BUILDER_STATE_HASH_STRUCTURE.TDS_WINDOW_COLUMN_STATE,
       hashArray(this.windowColumns),
       this.sortByState ?? '',
-      this.operationState,
+      this.operatorState,
       this.columnName,
     ]);
   }
@@ -362,14 +383,14 @@ export class QueryBuilderWindowState implements Hashable {
     const windowCols = this.windowColumns;
     windowCols.forEach((item, index) => {
       if (
-        item.operationState instanceof
+        item.operatorState instanceof
         QueryBuilderTDS_WindowAggreationOperatorState
       ) {
         if (
-          item.operationState.columnState instanceof
+          item.operatorState.columnState instanceof
           QueryBuilderWindowColumnState
         ) {
-          const windowColumnName = item.operationState.columnState.columnName;
+          const windowColumnName = item.operatorState.columnState.columnName;
           const hasExistingColumn = item.windowState.isColumnOrderValid(
             windowColumnName,
             index,
@@ -403,6 +424,17 @@ export class QueryBuilderWindowState implements Hashable {
     if (hasDuplicatedWindowColumns) {
       issues.push(`Query has duplicated window columns`);
     }
+
+    const hasDuplicatedProjectionWindowColumns = this.windowColumns.some(
+      (column) =>
+        this.tdsState.projectionColumns.filter(
+          (c) => c.columnName === column.columnName,
+        ).length > 0,
+    );
+    if (hasDuplicatedProjectionWindowColumns) {
+      issues.push('Query has duplicated projection/window columns');
+    }
+
     return issues;
   }
 

package/src/stores/fetch-structure/tds/window/QueryBuilderWindowValueSpecificationBuilder.ts

@@ -77,7 +77,7 @@ const appendOLAPGroupByColumnState = (
   }
 
   // create olap operation expression
-  const operationState = olapGroupByColumnState.operationState;
+  const operationState = olapGroupByColumnState.operatorState;
   const olapFunc = extractElementNameFromPath(operationState.operator.pureFunc);
   const olapFuncExpression = new SimpleFunctionExpression(olapFunc);
   olapFuncExpression.parametersValues = [