@finos/legend-query-builder 0.6.23 → 0.6.24

package/src/components/workflows/ClassQueryBuilder.tsx

@@ -157,7 +157,7 @@ const ClassQueryBuilderSetupPanelContent = observer(
                 filterOption={mappingFilterOption}
                 formatOptionLabel={getPackageableElementOptionFormatter({
                   darkMode: !applicationStore.TEMPORARY__isLightThemeEnabled,
-                  pureModel: queryBuilderState.graphManagerState.graph,
+                  graph: queryBuilderState.graphManagerState.graph,
                 })}
               />
             </div>

package/src/components/workflows/MappingQueryBuilder.tsx

@@ -151,7 +151,7 @@ const MappingQueryBuilderSetupPanelContent = observer(
                 filterOption={mappingFilterOption}
                 formatOptionLabel={getPackageableElementOptionFormatter({
                   darkMode: !applicationStore.TEMPORARY__isLightThemeEnabled,
-                  pureModel: queryBuilderState.graphManagerState.graph,
+                  graph: queryBuilderState.graphManagerState.graph,
                 })}
               />
             </div>

package/src/graphManager/QueryBuilderHashUtils.ts

@@ -67,20 +67,20 @@ export enum QUERY_BUILDER_HASH_STRUCTURE {
   WATERMARK_STATE = 'WATERMARK_STATE',
 
   // OLAPGroup state
-  TDS_OLAP_GROUPBY_STATE = 'TDS_OLAP_GROUPBY_STATE',
-  TDS_OLAP_GROUPBY_OPERATION_STATE = 'TDS_OLAP_GROUPBY_OPERATION_STATE',
-  TDS_OLAP_GROUPBY_AGG_OPERATION_STATE = 'TDS_OLAP_GROUPBY_AGG_OPERATION_STATE',
-  TDS_OLAP_GROUPBY_COLUMN_STATE = 'TDS_OLAP_GROUPBY_COLUMN_STATE',
-  TDS_OLAP_GROUPBY_COLUMN_SORTBY_STATE = 'TDS_OLAP_GROUPBY_COLUMN_SORTBY_STATE',
-  TDS_OLAP_OPERATOR_RANK = 'TDS_OLAP_OPERATOR_RANK',
-  TDS_OLAP_OPERATOR_AVERAGE_RANK = 'TDS_OLAP_OPERATOR_AVERAGE_RANK',
-  TDS_OLAP_OPERATOR_DENSE_RANK = 'TDS_OLAP_OPERATOR_DENSE_RANK',
-  TDS_OLAP_OPERATOR_ROW_NUMBER = 'TDS_OLAP_OPERATOR_ROW_NUMBER',
-  TDS_OLAP_OPERATOR_SUM = 'TDS_OLAP_OPERATOR_SUM',
-  TDS_OLAP_OPERATOR_MAX = 'TDS_OLAP_OPERATOR_MAX',
-  TDS_OLAP_OPERATOR_MIN = 'TDS_OLAP_OPERATOR_MIN',
-  TDS_OLAP_OPERATOR_COUNT = 'TDS_OLAP_OPERATOR_COUNT',
-  TDS_OLAP_OPERATOR_AVERAGE = 'TDS_OLAP_OPERATOR_AVERAGE',
+  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_COLUMN_STATE = 'TDS_WINDOW_COLUMN_STATE',
+  TDS_WINDOW_COLUMN_SORTBY_STATE = 'TDS_WINDOW_COLUMN_SORTBY_STATE',
+  TDS_WINDOW_OPERATOR_RANK = 'TDS_WINDOW_OPERATOR_RANK',
+  TDS_WINDOW_OPERATOR_AVERAGE_RANK = 'TDS_WINDOW_OPERATOR_AVERAGE_RANK',
+  TDS_WINDOW_OPERATOR_DENSE_RANK = 'TDS_WINDOW_OPERATOR_DENSE_RANK',
+  TDS_WINDOW_OPERATOR_ROW_NUMBER = 'TDS_WINDOW_OPERATOR_ROW_NUMBER',
+  TDS_WINDOW_OPERATOR_SUM = 'TDS_WINDOW_OPERATOR_SUM',
+  TDS_WINDOW_OPERATOR_MAX = 'TDS_WINDOW_OPERATOR_MAX',
+  TDS_WINDOW_OPERATOR_MIN = 'TDS_WINDOW_OPERATOR_MIN',
+  TDS_WINDOW_OPERATOR_COUNT = 'TDS_WINDOW_OPERATOR_COUNT',
+  TDS_WINDOW_OPERATOR_AVERAGE = 'TDS_WINDOW_OPERATOR_AVERAGE',
 
   // filter state
   FILTER_TREE_GROUP_NODE_DATA = 'FILTER_TREE_GROUP_NODE_DATA',

package/src/stores/QueryBuilderStateBuilder.ts

@@ -66,7 +66,7 @@ import {
 } from './fetch-structure/tds/projection/QueryBuilderProjectionStateBuilder.js';
 import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../graphManager/QueryBuilderSupportedFunctions.js';
 import { LambdaParameterState } from './shared/LambdaParameterState.js';
-import { processTDS_OLAPGroupByExpression } from './fetch-structure/tds/olapGroupBy/QueryBuilderOLAPGroupByStateBuilder.js';
+import { processTDS_OLAPGroupByExpression } from './fetch-structure/tds/window/QueryBuilderWindowStateBuilder.js';
 import { processWatermarkExpression } from './watermark/QueryBuilderWatermarkStateBuilder.js';
 import { QueryBuilderConstantExpressionState } from './QueryBuilderConstantsState.js';
 

package/src/stores/QueryBuilderValueSpecificationBuilder.ts

@@ -132,7 +132,6 @@ export const buildLambdaFunction = (
       _class,
       Multiplicity.ONE,
     );
-
     lambdaFunction.expressionSequence[0] = getAllVersionsFunction;
   } else {
     // build getAll()
@@ -169,7 +168,10 @@ export const buildLambdaFunction = (
     ];
   }
   // build parameters
-  if (queryBuilderState.parametersState.parameterStates.length) {
+  if (
+    queryBuilderState.parametersState.parameterStates.length &&
+    !options?.useAllVersionsForMilestoning
+  ) {
     if (options?.isBuildingExecutionQuery) {
       buildExecutionQueryFromLambdaFunction(
         lambdaFunction,

package/src/stores/QueryBuilderValueSpecificationBuilderHelper.ts

@@ -102,7 +102,9 @@ export const buildPropertyExpressionChain = (
         const name = currentExpression.func.value.name;
         const property =
           currentExpression.func.value._OWNER._generatedMilestonedProperties.find(
-            (e) => e.name === `${name}${MILESTONING_VERSION_PROPERTY_SUFFIX}`,
+            (e) =>
+              e.name ===
+              `${name}${MILESTONING_VERSION_PROPERTY_SUFFIX.ALL_VERSIONS}`,
           );
         if (property) {
           propertyExpression_setFunc(

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

@@ -92,9 +92,9 @@ import type { LambdaFunctionBuilderOption } from '../../QueryBuilderValueSpecifi
 import { appendProjection } from './projection/QueryBuilderProjectionValueSpecificationBuilder.js';
 import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../graphManager/QueryBuilderSupportedFunctions.js';
 import { QUERY_BUILDER_HASH_STRUCTURE } from '../../../graphManager/QueryBuilderHashUtils.js';
-import { QueryBuilderOLAPGroupByState } from './olapGroupBy/QueryBuilderOLAPGroupByState.js';
-import type { QueryBuilderTDS_OLAPOperator } from './olapGroupBy/operators/QueryBuilderTDS_OLAPOperator.js';
-import { getQueryBuilderCoreOLAPGroupByOperators } from './olapGroupBy/QueryBuilderOLAPGroupByOperatorLoader.js';
+import { QueryBuilderWindowState } from './window/QueryBuilderWindowState.js';
+import type { QueryBuilderTDS_WindowOperator } from './window/operators/QueryBuilderTDS_WindowOperator.js';
+import { getQueryBuilderCoreWindowOperators } from './window/QueryBuilderWindowGroupByOperatorLoader.js';
 import type { QueryBuilderTDSColumnState } from './QueryBuilderTDSColumnState.js';
 
 export class QueryBuilderTDSState
@@ -103,19 +103,19 @@ export class QueryBuilderTDSState
 {
   readonly aggregationState: QueryBuilderAggregationState;
   readonly postFilterState: QueryBuilderPostFilterState;
-  readonly olapGroupByState: QueryBuilderOLAPGroupByState;
+  readonly windowState: QueryBuilderWindowState;
   readonly resultSetModifierState: QueryResultSetModifierState;
   projectionColumns: QueryBuilderProjectionColumnState[] = [];
   isConvertDerivationProjectionObjects = false;
   showPostFilterPanel = false;
-  showOlapGroupByPanel = false;
+  showWindowFuncPanel = false;
 
   postFilterOperators: QueryBuilderPostFilterOperator[] =
     getQueryBuilderCorePostFilterOperators();
   aggregationOperators: QueryBuilderAggregateOperator[] =
     getQueryBuilderCoreAggregrationOperators();
-  olapGroupByOperators: QueryBuilderTDS_OLAPOperator[] =
-    getQueryBuilderCoreOLAPGroupByOperators();
+  windowFuncOperators: QueryBuilderTDS_WindowOperator[] =
+    getQueryBuilderCoreWindowOperators();
 
   constructor(
     queryBuilderState: QueryBuilderState,
@@ -127,7 +127,7 @@ export class QueryBuilderTDSState
       projectionColumns: observable,
       isConvertDerivationProjectionObjects: observable,
       showPostFilterPanel: observable,
-      showOlapGroupByPanel: observable,
+      showWindowFuncPanel: observable,
       TEMPORARY__showPostFetchStructurePanel: computed,
       derivations: computed,
       hasParserError: computed,
@@ -135,7 +135,7 @@ export class QueryBuilderTDSState
       moveColumn: action,
       replaceColumn: action,
       setShowPostFilterPanel: action,
-      setShowOlapGroupByPanel: action,
+      setShowWindowFuncPanel: action,
       convertDerivationProjectionObjects: flow,
     });
 
@@ -148,9 +148,9 @@ export class QueryBuilderTDSState
       this,
       this.aggregationOperators,
     );
-    this.olapGroupByState = new QueryBuilderOLAPGroupByState(
+    this.windowState = new QueryBuilderWindowState(
       this,
-      this.olapGroupByOperators,
+      this.windowFuncOperators,
     );
   }
 
@@ -173,7 +173,7 @@ export class QueryBuilderTDSState
   override get TEMPORARY__showPostFetchStructurePanel(): boolean {
     return (
       this.queryBuilderState.filterState.showPanel ||
-      this.showOlapGroupByPanel ||
+      this.showWindowFuncPanel ||
       this.showPostFilterPanel
     );
   }
@@ -279,7 +279,7 @@ export class QueryBuilderTDSState
     return [
       ...this.aggregationState.columns,
       ...projectionColumns,
-      ...this.olapGroupByState.olapColumns,
+      ...this.windowState.windowColumns,
     ];
   }
 
@@ -293,7 +293,7 @@ export class QueryBuilderTDSState
     return Boolean(
       [
         ...this.postFilterState.referencedTDSColumns,
-        ...this.olapGroupByState.referencedTDSColumns,
+        ...this.windowState.referencedTDSColumns,
       ].find((col) => {
         if (col instanceof QueryBuilderAggregateColumnState) {
           return tdsCol instanceof QueryBuilderAggregateColumnState
@@ -320,8 +320,8 @@ export class QueryBuilderTDSState
     this.showPostFilterPanel = val;
   }
 
-  setShowOlapGroupByPanel(val: boolean): void {
-    this.showOlapGroupByPanel = val;
+  setShowWindowFuncPanel(val: boolean): void {
+    this.showWindowFuncPanel = val;
   }
 
   *convertDerivationProjectionObjects(): GeneratorFn<void> {

package/src/stores/fetch-structure/tds/post-filter/operators/QueryBuilderPostFilterOperatorHelper.ts

@@ -17,7 +17,7 @@
 import { Multiplicity } from '@finos/legend-graph';
 import { UnsupportedOperationError } from '@finos/legend-shared';
 import { QueryBuilderAggregateColumnState } from '../../aggregation/QueryBuilderAggregationState.js';
-import { QueryBuilderOLAPGroupByColumnState } from '../../olapGroupBy/QueryBuilderOLAPGroupByState.js';
+import { QueryBuilderWindowColumnState } from '../../window/QueryBuilderWindowState.js';
 import { QueryBuilderSimpleProjectionColumnState } from '../../projection/QueryBuilderProjectionColumnState.js';
 import type { QueryBuilderTDSColumnState } from '../../QueryBuilderTDSColumnState.js';
 
@@ -26,7 +26,7 @@ export const getColumnMultiplicity = (
 ): Multiplicity => {
   if (
     columnState instanceof QueryBuilderAggregateColumnState ||
-    columnState instanceof QueryBuilderOLAPGroupByColumnState
+    columnState instanceof QueryBuilderWindowColumnState
   ) {
     return Multiplicity.ONE;
   } else if (columnState instanceof QueryBuilderSimpleProjectionColumnState) {

package/src/stores/fetch-structure/tds/projection/QueryBuilderProjectionValueSpecificationBuilder.ts

@@ -47,7 +47,7 @@ import {
 import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../../graphManager/QueryBuilderSupportedFunctions.js';
 import { buildGenericLambdaFunctionInstanceValue } from '../../../QueryBuilderValueSpecificationHelper.js';
 import { buildPropertyExpressionChain } from '../../../QueryBuilderValueSpecificationBuilderHelper.js';
-import { appendOLAPGroupByState } from '../olapGroupBy/QueryBuilderOLAPGroupByValueSpecificationBuilder.js';
+import { appendOLAPGroupByState } from '../window/QueryBuilderWindowValueSpecificationBuilder.js';
 import { appendPostFilter } from '../post-filter/QueryBuilderPostFilterValueSpecificationBuilder.js';
 
 const buildSortExpression = (
@@ -370,7 +370,7 @@ export const appendProjection = (
   }
 
   // build olapGroupBy
-  appendOLAPGroupByState(tdsState.olapGroupByState, lambdaFunction);
+  appendOLAPGroupByState(tdsState.windowState, lambdaFunction);
 
   // build post-filter
   appendPostFilter(tdsState.postFilterState, lambdaFunction);

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

@@ -0,0 +1,39 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import type { QueryBuilderTDS_WindowOperator } from './operators/QueryBuilderTDS_WindowOperator.js';
+import { QueryBuilderTDS_WindowRankOperator_AverageRank } from './operators/QueryBuilderTDS_WindowRankOperator_AverageRank.js';
+import { QueryBuilderTDS_WindowRankOperator_DenseRank } from './operators/QueryBuilderTDS_WindowRankOperator_DenseRank.js';
+import { QueryBuilderTDS_WindowRankOperator_Rank } from './operators/QueryBuilderTDS_WindowRankOperator_Rank.js';
+import { QueryBuilderTDS_WindowRankOperator_RowNumber } from './operators/QueryBuilderTDS_WindowRankOperator_RowNumber.js';
+import { QueryBuilderTDS_WindowOperator_Sum } from './operators/QueryBuilderTDS_WindowOperator_Sum.js';
+import { QueryBuilderTDS_WindowOperator_Count } from './operators/QueryBuilderTDS_WindowOperator_Count.js';
+import { QueryBuilderTDS_WindowOperator_Max } from './operators/QueryBuilderTDS_WindowOperator_Max.js';
+import { QueryBuilderTDS_WindowOperator_Min } from './operators/QueryBuilderTDS_WindowOperator_Min.js';
+import { QueryBuilderTDS_WindowOperator_Average } from './operators/QueryBuilderTDS_WindowOperator_Average.js';
+
+export const getQueryBuilderCoreWindowOperators =
+  (): QueryBuilderTDS_WindowOperator[] => [
+    new QueryBuilderTDS_WindowOperator_Sum(),
+    new QueryBuilderTDS_WindowOperator_Count(),
+    new QueryBuilderTDS_WindowOperator_Max(),
+    new QueryBuilderTDS_WindowOperator_Min(),
+    new QueryBuilderTDS_WindowOperator_Average(),
+    new QueryBuilderTDS_WindowRankOperator_AverageRank(),
+    new QueryBuilderTDS_WindowRankOperator_DenseRank(),
+    new QueryBuilderTDS_WindowRankOperator_Rank(),
+    new QueryBuilderTDS_WindowRankOperator_RowNumber(),
+  ];

package/src/stores/fetch-structure/tds/{olapGroupBy/QueryBuilderOLAPGroupByState.ts → window/QueryBuilderWindowState.ts}

@@ -30,19 +30,19 @@ import type { QueryBuilderProjectionColumnDragSource } from '../projection/Query
 import { QueryBuilderTDSColumnState } from '../QueryBuilderTDSColumnState.js';
 import type { QueryBuilderTDSState } from '../QueryBuilderTDSState.js';
 import type { COLUMN_SORT_TYPE } from '../QueryResultSetModifierState.js';
-import type { QueryBuilderTDS_OLAPOperator } from './operators/QueryBuilderTDS_OLAPOperator.js';
+import type { QueryBuilderTDS_WindowOperator } from './operators/QueryBuilderTDS_WindowOperator.js';
 
-export const QUERY_BUILDER_OLAP_COLUMN_DND_TYPE = 'OLAP_COLUMN';
+export const QUERY_BUILDER_WINDOW_COLUMN_DND_TYPE = 'WINDOW_COLUMN';
 
-export interface QueryBuilderOLAPColumnDragSource {
+export interface QueryBuilderWindowColumnDragSource {
   columnState: QueryBuilderTDSColumnState;
 }
 
-export type QueryBuilderOLAPDropTarget =
+export type QueryBuilderWindowDropTarget =
   | QueryBuilderProjectionColumnDragSource
-  | QueryBuilderOLAPColumnDragSource;
+  | QueryBuilderWindowColumnDragSource;
 
-export class OLAPGroupByColumnSortByState implements Hashable {
+export class WindowGroupByColumnSortByState implements Hashable {
   columnState: QueryBuilderTDSColumnState;
   sortType: COLUMN_SORT_TYPE;
 
@@ -71,23 +71,23 @@ export class OLAPGroupByColumnSortByState implements Hashable {
 
   get hashCode(): string {
     return hashArray([
-      QUERY_BUILDER_HASH_STRUCTURE.TDS_OLAP_GROUPBY_COLUMN_SORTBY_STATE,
+      QUERY_BUILDER_HASH_STRUCTURE.TDS_WINDOW_COLUMN_SORTBY_STATE,
       this.sortType,
       this.columnState.columnName,
     ]);
   }
 }
 
-export abstract class QueryBuilderTDS_OLAPOperatorState implements Hashable {
-  readonly olapState: QueryBuilderOLAPGroupByState;
+export abstract class QueryBuilderTDS_WindowOperatorState implements Hashable {
+  readonly windowState: QueryBuilderWindowState;
   lambdaParameterName: string = DEFAULT_LAMBDA_VARIABLE_NAME;
-  operator: QueryBuilderTDS_OLAPOperator;
+  operator: QueryBuilderTDS_WindowOperator;
 
   constructor(
-    olapState: QueryBuilderOLAPGroupByState,
-    operator: QueryBuilderTDS_OLAPOperator,
+    windowState: QueryBuilderWindowState,
+    operator: QueryBuilderTDS_WindowOperator,
   ) {
-    this.olapState = olapState;
+    this.windowState = windowState;
     this.operator = operator;
   }
 
@@ -95,39 +95,39 @@ export abstract class QueryBuilderTDS_OLAPOperatorState implements Hashable {
     this.lambdaParameterName = paramName;
   }
 
-  setOperator(val: QueryBuilderTDS_OLAPOperator): void {
+  setOperator(val: QueryBuilderTDS_WindowOperator): void {
     this.operator = val;
   }
 
   get hashCode(): string {
     return hashArray([
-      QUERY_BUILDER_HASH_STRUCTURE.TDS_OLAP_GROUPBY_OPERATION_STATE,
+      QUERY_BUILDER_HASH_STRUCTURE.TDS_WINDOW_GROUPBY_OPERATION_STATE,
       this.lambdaParameterName,
       this.operator,
     ]);
   }
 }
 
-export class QueryBuilderTDS_OLAPRankOperatorState extends QueryBuilderTDS_OLAPOperatorState {
+export class QueryBuilderTDS_WindowRankOperatorState extends QueryBuilderTDS_WindowOperatorState {
   constructor(
-    olapState: QueryBuilderOLAPGroupByState,
-    operator: QueryBuilderTDS_OLAPOperator,
+    windowState: QueryBuilderWindowState,
+    operator: QueryBuilderTDS_WindowOperator,
   ) {
-    super(olapState, operator);
+    super(windowState, operator);
     makeObservable(this, {
       setLambdaParameterName: action,
     });
   }
 }
 
-export class QueryBuilderTDS_OLAPAggreationOperatorState extends QueryBuilderTDS_OLAPOperatorState {
+export class QueryBuilderTDS_WindowAggreationOperatorState extends QueryBuilderTDS_WindowOperatorState {
   columnState: QueryBuilderTDSColumnState;
   constructor(
-    olapState: QueryBuilderOLAPGroupByState,
-    operator: QueryBuilderTDS_OLAPOperator,
+    windowState: QueryBuilderWindowState,
+    operator: QueryBuilderTDS_WindowOperator,
     columnState: QueryBuilderTDSColumnState,
   ) {
-    super(olapState, operator);
+    super(windowState, operator);
     makeObservable(this, {
       columnState: observable,
       setColumnState: action,
@@ -142,7 +142,7 @@ export class QueryBuilderTDS_OLAPAggreationOperatorState extends QueryBuilderTDS
 
   override get hashCode(): string {
     return hashArray([
-      QUERY_BUILDER_HASH_STRUCTURE.TDS_OLAP_GROUPBY_AGG_OPERATION_STATE,
+      QUERY_BUILDER_HASH_STRUCTURE.TDS_WINDOW_GROUPBY_AGG_OPERATION_STATE,
       this.lambdaParameterName,
       this.operator,
       this.columnState.columnName,
@@ -150,21 +150,21 @@ export class QueryBuilderTDS_OLAPAggreationOperatorState extends QueryBuilderTDS
   }
 }
 
-export class QueryBuilderOLAPGroupByColumnState
+export class QueryBuilderWindowColumnState
   extends QueryBuilderTDSColumnState
   implements Hashable
 {
-  readonly olapState: QueryBuilderOLAPGroupByState;
+  readonly windowState: QueryBuilderWindowState;
   windowColumns: QueryBuilderTDSColumnState[] = [];
-  sortByState: OLAPGroupByColumnSortByState | undefined;
-  operationState: QueryBuilderTDS_OLAPOperatorState;
+  sortByState: WindowGroupByColumnSortByState | undefined;
+  operationState: QueryBuilderTDS_WindowOperatorState;
   columnName: string;
 
   constructor(
-    olapState: QueryBuilderOLAPGroupByState,
+    windowState: QueryBuilderWindowState,
     windowColumns: QueryBuilderTDSColumnState[],
-    sortType: OLAPGroupByColumnSortByState | undefined,
-    operationState: QueryBuilderTDS_OLAPOperatorState,
+    sortType: WindowGroupByColumnSortByState | undefined,
+    operationState: QueryBuilderTDS_WindowOperatorState,
     columnName: string,
   ) {
     super();
@@ -182,29 +182,32 @@ export class QueryBuilderOLAPGroupByColumnState
       changeOperator: action,
       changeSortBy: action,
     });
-    this.olapState = olapState;
+    this.windowState = windowState;
     this.windowColumns = windowColumns;
     this.sortByState = sortType;
     this.operationState = operationState;
     this.columnName = columnName;
   }
 
-  get columnOLAPGroupIdx(): number {
-    return this.olapState.olapColumns.findIndex((e) => e === this);
+  get columnWindowGroupIdx(): number {
+    return this.windowState.windowColumns.findIndex((e) => e === this);
   }
 
   get possibleReferencedColumns(): QueryBuilderTDSColumnState[] {
-    // column can only reference TDS columns already defined, i.e in an earlier index of the olap columns
-    const idx = this.olapState.tdsState.tdsColumns.findIndex((e) => e === this);
+    // column can only reference TDS columns already defined, i.e in an earlier index of the window columns
+    const idx = this.windowState.tdsState.tdsColumns.findIndex(
+      (e) => e === this,
+    );
     if (idx === -1) {
-      return this.olapState.tdsState.tdsColumns;
+      return this.windowState.tdsState.tdsColumns;
     }
-    return this.olapState.tdsState.tdsColumns.slice(0, idx);
+    return this.windowState.tdsState.tdsColumns.slice(0, idx);
   }
 
   get referencedTDSColumns(): QueryBuilderTDSColumnState[] {
     const operatorReference =
-      this.operationState instanceof QueryBuilderTDS_OLAPAggreationOperatorState
+      this.operationState instanceof
+      QueryBuilderTDS_WindowAggreationOperatorState
         ? [this.operationState.columnState]
         : [];
     const soryByReference = this.sortByState
@@ -215,7 +218,7 @@ export class QueryBuilderOLAPGroupByColumnState
 
   getColumnType(): Type | undefined {
     return this.operationState.operator.getOperatorReturnType(
-      this.olapState.tdsState.queryBuilderState.graphManagerState.graph,
+      this.windowState.tdsState.queryBuilderState.graphManagerState.graph,
     );
   }
 
@@ -223,11 +226,11 @@ export class QueryBuilderOLAPGroupByColumnState
     this.columnName = val;
   }
 
-  setOperatorState(op: QueryBuilderTDS_OLAPOperatorState): void {
+  setOperatorState(op: QueryBuilderTDS_WindowOperatorState): void {
     this.operationState = op;
   }
 
-  setSortBy(val: OLAPGroupByColumnSortByState | undefined): void {
+  setSortBy(val: WindowGroupByColumnSortByState | undefined): void {
     this.sortByState = val;
   }
 
@@ -244,7 +247,7 @@ export class QueryBuilderOLAPGroupByColumnState
   }
 
   possibleAggregatedColumns(
-    op: QueryBuilderTDS_OLAPOperator,
+    op: QueryBuilderTDS_WindowOperator,
   ): QueryBuilderTDSColumnState[] {
     if (op.isColumnAggregator()) {
       return this.possibleReferencedColumns.filter((col) =>
@@ -254,31 +257,35 @@ export class QueryBuilderOLAPGroupByColumnState
     return [];
   }
 
-  changeOperator(olapOp: QueryBuilderTDS_OLAPOperator): void {
+  changeOperator(windowOp: QueryBuilderTDS_WindowOperator): void {
     const currentOperator = this.operationState.operator;
     const currentAggregateColumn =
-      this.operationState instanceof QueryBuilderTDS_OLAPAggreationOperatorState
+      this.operationState instanceof
+      QueryBuilderTDS_WindowAggreationOperatorState
         ? this.operationState.columnState
         : undefined;
-    if (currentOperator !== olapOp) {
-      if (olapOp.isColumnAggregator()) {
+    if (currentOperator !== windowOp) {
+      if (windowOp.isColumnAggregator()) {
         const compatibleAggCol =
           currentAggregateColumn &&
-          olapOp.isCompatibleWithColumn(currentAggregateColumn)
+          windowOp.isCompatibleWithColumn(currentAggregateColumn)
             ? currentAggregateColumn
-            : this.possibleAggregatedColumns(olapOp)[0];
+            : this.possibleAggregatedColumns(windowOp)[0];
         if (compatibleAggCol) {
           this.setOperatorState(
-            new QueryBuilderTDS_OLAPAggreationOperatorState(
-              this.olapState,
-              olapOp,
+            new QueryBuilderTDS_WindowAggreationOperatorState(
+              this.windowState,
+              windowOp,
               compatibleAggCol,
             ),
           );
         }
       } else {
         this.setOperatorState(
-          new QueryBuilderTDS_OLAPRankOperatorState(this.olapState, olapOp),
+          new QueryBuilderTDS_WindowRankOperatorState(
+            this.windowState,
+            windowOp,
+          ),
         );
       }
     }
@@ -290,7 +297,7 @@ export class QueryBuilderOLAPGroupByColumnState
       if (sortOp) {
         const sortInfoOpState =
           sortByState ??
-          new OLAPGroupByColumnSortByState(
+          new WindowGroupByColumnSortByState(
             guaranteeNonNullable(this.possibleReferencedColumns[0]),
             sortOp,
           );
@@ -304,7 +311,7 @@ export class QueryBuilderOLAPGroupByColumnState
 
   get hashCode(): string {
     return hashArray([
-      QUERY_BUILDER_HASH_STRUCTURE.TDS_OLAP_GROUPBY_COLUMN_STATE,
+      QUERY_BUILDER_HASH_STRUCTURE.TDS_WINDOW_COLUMN_STATE,
       hashArray(this.windowColumns),
       this.sortByState ?? '',
       this.operationState,
@@ -313,20 +320,20 @@ export class QueryBuilderOLAPGroupByColumnState
   }
 }
 
-export class QueryBuilderOLAPGroupByState implements Hashable {
+export class QueryBuilderWindowState implements Hashable {
   readonly tdsState: QueryBuilderTDSState;
-  olapColumns: QueryBuilderOLAPGroupByColumnState[] = [];
-  operators: QueryBuilderTDS_OLAPOperator[];
-  editColumn: QueryBuilderOLAPGroupByColumnState | undefined;
+  windowColumns: QueryBuilderWindowColumnState[] = [];
+  operators: QueryBuilderTDS_WindowOperator[];
+  editColumn: QueryBuilderWindowColumnState | undefined;
 
   constructor(
     tdsState: QueryBuilderTDSState,
-    operators: QueryBuilderTDS_OLAPOperator[],
+    operators: QueryBuilderTDS_WindowOperator[],
   ) {
     makeObservable(this, {
-      olapColumns: observable,
+      windowColumns: observable,
       editColumn: observable,
-      addOLAPColumn: action,
+      addWindowColumn: action,
       removeColumn: action,
       moveColumn: action,
       setEditColumn: action,
@@ -336,42 +343,42 @@ export class QueryBuilderOLAPGroupByState implements Hashable {
   }
 
   get isEmpty(): boolean {
-    return !this.olapColumns.length;
+    return !this.windowColumns.length;
   }
 
   get referencedTDSColumns(): QueryBuilderTDSColumnState[] {
-    return uniq(this.olapColumns.map((c) => c.referencedTDSColumns).flat());
+    return uniq(this.windowColumns.map((c) => c.referencedTDSColumns).flat());
   }
 
-  setEditColumn(col: QueryBuilderOLAPGroupByColumnState | undefined): void {
+  setEditColumn(col: QueryBuilderWindowColumnState | undefined): void {
     this.editColumn = col;
   }
 
-  findOperator(func: string): QueryBuilderTDS_OLAPOperator | undefined {
+  findOperator(func: string): QueryBuilderTDS_WindowOperator | undefined {
     return this.operators.find((o) => matchFunctionName(func, o.pureFunc));
   }
 
-  addOLAPColumn(olapGroupByCol: QueryBuilderOLAPGroupByColumnState): void {
-    addUniqueEntry(this.olapColumns, olapGroupByCol);
+  addWindowColumn(windowCol: QueryBuilderWindowColumnState): void {
+    addUniqueEntry(this.windowColumns, windowCol);
   }
 
-  removeColumn(column: QueryBuilderOLAPGroupByColumnState): void {
-    deleteEntry(this.olapColumns, column);
+  removeColumn(column: QueryBuilderWindowColumnState): void {
+    deleteEntry(this.windowColumns, column);
   }
 
   moveColumn(fromIndex: number, toIndex: number): void {
-    const fromCol = this.olapColumns[fromIndex];
-    const toCol = this.olapColumns[toIndex];
+    const fromCol = this.windowColumns[fromIndex];
+    const toCol = this.windowColumns[toIndex];
     if (fromCol && toCol) {
-      this.olapColumns[fromIndex] = toCol;
-      this.olapColumns[toIndex] = fromCol;
+      this.windowColumns[fromIndex] = toCol;
+      this.windowColumns[toIndex] = fromCol;
     }
   }
 
   get hashCode(): string {
     return hashArray([
-      QUERY_BUILDER_HASH_STRUCTURE.TDS_OLAP_GROUPBY_STATE,
-      hashArray(this.olapColumns),
+      QUERY_BUILDER_HASH_STRUCTURE.TDS_WINDOW_GROUPBY_STATE,
+      hashArray(this.windowColumns),
     ]);
   }
 }