@finos/legend-query-builder 0.2.3 → 0.3.1

package/src/graphManager/protocol/pure/QueryBuilder_PureProtocolProcessorPlugin.ts

@@ -20,6 +20,7 @@ import {
   V1_buildFilterFunctionExpression,
   V1_buildGetAllFunctionExpression,
   V1_buildGroupByFunctionExpression,
+  V1_buildOlapGroupByFunctionExpression,
   V1_buildProjectFunctionExpression,
   V1_buildSubTypePropertyExpressionTypeInference,
 } from './v1/V1_QueryValueSpecificationBuilderHelper.js';
@@ -121,6 +122,19 @@ export class QueryBuilder_PureProtocolProcessorPlugin extends PureProtocolProces
             compileContext,
             processingContext,
           );
+        } else if (
+          matchFunctionName(
+            functionName,
+            QUERY_BUILDER_SUPPORTED_FUNCTIONS.OLAP_GROUPBY,
+          )
+        ) {
+          return V1_buildOlapGroupByFunctionExpression(
+            functionName,
+            parameters,
+            openVariables,
+            compileContext,
+            processingContext,
+          );
         } else if (
           matchFunctionName(
             functionName,

package/src/graphManager/protocol/pure/v1/V1_QueryValueSpecificationBuilderHelper.ts

@@ -570,6 +570,135 @@ export const V1_buildGroupByFunctionExpression = (
   return [expression, processedParams];
 };
 
+export const V1_buildOlapGroupByFunctionExpression = (
+  functionName: string,
+  parameters: V1_ValueSpecification[],
+  openVariables: string[],
+  compileContext: V1_GraphBuilderContext,
+  processingContext: V1_ProcessingContext,
+): [SimpleFunctionExpression, ValueSpecification[]] | undefined => {
+  const processedParams: ValueSpecification[] = [];
+  assertTrue(
+    parameters.length === 5 || parameters.length === 4,
+    `Can't build olapGroupBy() expression: olapGroupBy() expects 4 or 5 arguments`,
+  );
+  let paramIndex = 0;
+  const containsSortByExpression = parameters.length === 5;
+
+  // preceding expression
+  const precedingExperession = (
+    parameters[paramIndex] as V1_ValueSpecification
+  ).accept_ValueSpecificationVisitor(
+    new V1_ValueSpecificationBuilder(
+      compileContext,
+      processingContext,
+      openVariables,
+    ),
+  );
+  assertNonNullable(
+    precedingExperession.genericType,
+    `Can't build olapGroupBy() expression: preceding expression return type is missing`,
+  );
+  processedParams.push(precedingExperession);
+  paramIndex++;
+
+  // partition (window) columns
+  const columns = (
+    parameters[paramIndex] as V1_ValueSpecification
+  ).accept_ValueSpecificationVisitor(
+    new V1_ValueSpecificationBuilder(
+      compileContext,
+      processingContext,
+      openVariables,
+    ),
+  );
+  processedParams.push(columns);
+  paramIndex++;
+
+  // OLAP sortBy
+  if (containsSortByExpression) {
+    const sortBy = (
+      parameters[paramIndex] as V1_ValueSpecification
+    ).accept_ValueSpecificationVisitor(
+      new V1_ValueSpecificationBuilder(
+        compileContext,
+        processingContext,
+        openVariables,
+      ),
+    );
+    processedParams.push(sortBy);
+    paramIndex++;
+  }
+
+  // OLAP agg operation
+  const olapOperatorExp = parameters[paramIndex];
+  let olapOperationLambda: V1_Lambda;
+  if (olapOperatorExp instanceof V1_AppliedFunction) {
+    olapOperationLambda = guaranteeType(
+      olapOperatorExp.parameters[1],
+      V1_Lambda,
+      `Can't build olapGroupBy() expression: olap operation function expects argument ${
+        paramIndex + 1
+      } to be a lambda`,
+    );
+  } else {
+    olapOperationLambda = guaranteeType(
+      olapOperatorExp,
+      V1_Lambda,
+      `Can't build olapGroupBy() expression: olapGroupBy() expects argument ${
+        paramIndex + 1
+      } to be a lambda`,
+    );
+  }
+  const olapOperationParameters = olapOperationLambda.parameters;
+  const variables = new Set<string>();
+  olapOperationParameters.forEach((variable) => {
+    if (!variables.has(variable.name) && !variable.class) {
+      const variableExpression = new VariableExpression(
+        variable.name,
+        precedingExperession.multiplicity,
+      );
+      variableExpression.genericType = precedingExperession.genericType;
+      processingContext.addInferredVariables(variable.name, variableExpression);
+    }
+  });
+  const olapOperation = (
+    olapOperatorExp as V1_ValueSpecification
+  ).accept_ValueSpecificationVisitor(
+    new V1_ValueSpecificationBuilder(
+      compileContext,
+      processingContext,
+      openVariables,
+    ),
+  );
+  processedParams.push(olapOperation);
+  paramIndex++;
+
+  // OLAP column name
+  const olapColumnName = (
+    parameters[paramIndex] as V1_ValueSpecification
+  ).accept_ValueSpecificationVisitor(
+    new V1_ValueSpecificationBuilder(
+      compileContext,
+      processingContext,
+      openVariables,
+    ),
+  );
+  processedParams.push(olapColumnName);
+  paramIndex++;
+
+  // build final expression
+  const expression = V1_buildBaseSimpleFunctionExpression(
+    processedParams,
+    functionName,
+    compileContext,
+  );
+  expression.genericType = GenericTypeExplicitReference.create(
+    new GenericType(compileContext.resolveType(CORE_PURE_PATH.TDS_ROW).value),
+  );
+  return [expression, processedParams];
+};
+
 export const V1_buildSubTypePropertyExpressionTypeInference = (
   inferredVariable: SimpleFunctionExpression,
 ): Type | undefined =>

package/src/stores/QueryBuilderStateBuilder.ts

@@ -70,6 +70,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 { processTDSOlapGroupByExpression } from './fetch-structure/tds/olapGroupBy/QueryBuilderOlapGroupByStateBuilder.js';
 
 const processGetAllExpression = (
   expression: SimpleFunctionExpression,
@@ -394,6 +395,7 @@ export class QueryBuilderValueSpecificationProcessor
         matchFunctionName(precedingExpression.functionName, [
           QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_PROJECT,
           QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_GROUP_BY,
+          QUERY_BUILDER_SUPPORTED_FUNCTIONS.OLAP_GROUPBY,
         ])
       ) {
         assertTrue(
@@ -410,7 +412,7 @@ export class QueryBuilderValueSpecificationProcessor
         return;
       } else {
         throw new UnsupportedOperationError(
-          `Can't process filter() expression: only support filter() immediately following getAll() or project()/groupBy()`,
+          `Can't process filter() expression: only support filter() immediately following getAll() or project()/groupBy()/olapGroupBy()`,
         );
       }
     } else if (
@@ -474,6 +476,17 @@ export class QueryBuilderValueSpecificationProcessor
         this.queryBuilderState,
       );
       return;
+    } else if (
+      matchFunctionName(
+        functionName,
+        QUERY_BUILDER_SUPPORTED_FUNCTIONS.OLAP_GROUPBY,
+      )
+    ) {
+      processTDSOlapGroupByExpression(
+        valueSpecification,
+        this.queryBuilderState,
+      );
+      return;
     } else if (
       matchFunctionName(
         functionName,

package/src/stores/QueryBuilderStateTestUtils.ts

@@ -25,8 +25,8 @@ import {
   TEST__buildGraphWithEntities,
   TEST__getTestGraphManagerState,
 } from '@finos/legend-graph';
+import { createSpy } from '@finos/legend-shared';
 import type { Entity } from '@finos/legend-storage';
-import { jest } from '@jest/globals';
 import { flowResult } from 'mobx';
 import { QueryBuilder_GraphManagerPreset } from '../graphManager/QueryBuilder_GraphManagerPreset.js';
 import {
@@ -75,18 +75,14 @@ export const TEST__setUpQueryBuilderState = async (
   }
 
   if (rawMappingModelCoverageAnalysisResult) {
-    jest
-      .spyOn(
-        queryBuilderState.graphManagerState.graphManager,
-        'analyzeMappingModelCoverage',
-      )
-      .mockReturnValue(
-        Promise.resolve(
-          queryBuilderState.graphManagerState.graphManager.buildMappingModelCoverageAnalysisResult(
-            rawMappingModelCoverageAnalysisResult,
-          ),
-        ),
-      );
+    createSpy(
+      queryBuilderState.graphManagerState.graphManager,
+      'analyzeMappingModelCoverage',
+    ).mockResolvedValue(
+      queryBuilderState.graphManagerState.graphManager.buildMappingModelCoverageAnalysisResult(
+        rawMappingModelCoverageAnalysisResult,
+      ),
+    );
   }
 
   if (rawMappingModelCoverageAnalysisResult) {

package/src/stores/QueryBuilderTypeaheadHelper.ts

@@ -20,7 +20,7 @@ import {
   type ValueSpecification,
   PrimitiveInstanceValue,
   PRIMITIVE_TYPE,
-  TdsExecutionResult,
+  TDSExecutionResult,
   type RawLambda,
 } from '@finos/legend-graph';
 import { guaranteeType, isNonNullable, isString } from '@finos/legend-shared';
@@ -120,7 +120,7 @@ export const buildProjectionColumnTypeaheadQuery = (
 export const buildTypeaheadOptions = (result: ExecutionResult): string[] => {
   const tdsResult = guaranteeType(
     result,
-    TdsExecutionResult,
+    TDSExecutionResult,
     'Typeahead search is only supported for TDS result sets',
   );
   const options: string[] = [];

package/src/stores/explorer/QueryBuilderExplorerState.ts

@@ -54,7 +54,7 @@ import {
   Property,
   Association,
   PRIMITIVE_TYPE,
-  TdsExecutionResult,
+  TDSExecutionResult,
   type ExecutionResult,
   getAllSubclasses,
   PropertyExplicitReference,
@@ -741,7 +741,7 @@ export class QueryBuilderExplorerState {
             )) as ExecutionResult;
           assertType(
             previewResult,
-            TdsExecutionResult,
+            TDSExecutionResult,
             `Unexpected preview data format`,
           );
           const previewResultData =
@@ -778,7 +778,7 @@ export class QueryBuilderExplorerState {
             )) as ExecutionResult;
           assertType(
             previewResult,
-            TdsExecutionResult,
+            TDSExecutionResult,
             `Unexpected preview data format`,
           );
           this.previewDataState.setPreviewData(

package/src/stores/fetch-structure/QueryBuilderFetchStructureImplementationState.ts

@@ -67,4 +67,8 @@ export abstract class QueryBuilderFetchStructureImplementationState
     options?: LambdaFunctionBuilderOption,
   ): void;
   abstract get hashCode(): string;
+
+  get TEMPORARY__showPostFetchStructurePanel(): boolean {
+    return this.queryBuilderState.filterState.showPanel;
+  }
 }

package/src/stores/fetch-structure/graph-fetch/QueryBuilderGraphFetchTreeState.ts

@@ -15,7 +15,7 @@
  */
 
 import type { QueryBuilderState } from '../../QueryBuilderState.js';
-import { action, makeObservable, observable } from 'mobx';
+import { action, computed, makeObservable, observable } from 'mobx';
 import {
   type CompilationError,
   PackageableElementExplicitReference,
@@ -73,6 +73,7 @@ export class QueryBuilderGraphFetchTreeState
     makeObservable(this, {
       treeData: observable.ref,
       isChecked: observable,
+      TEMPORARY__showPostFetchStructurePanel: computed,
       setGraphFetchTree: action,
       setChecked: action,
     });

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

@@ -0,0 +1,28 @@
+/**
+ * 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 Hashable, uuid } from '@finos/legend-shared';
+import type { Type } from '@finos/legend-graph';
+
+export abstract class QueryBuilderTDSColumnState implements Hashable {
+  readonly uuid = uuid();
+
+  abstract get columnName(): string;
+
+  abstract getColumnType(): Type | undefined;
+
+  abstract get hashCode(): string;
+}

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

@@ -0,0 +1,79 @@
+/**
+ * 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 {
+  extractElementNameFromPath,
+  matchFunctionName,
+} from '@finos/legend-graph';
+import {
+  guaranteeNonNullable,
+  UnsupportedOperationError,
+} from '@finos/legend-shared';
+import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../graphManager/QueryBuilderSupportedFunctions.js';
+import type { QueryBuilderTDSState } from './QueryBuilderTDSState.js';
+import type { QueryBuilderTDSColumnState } from './QueryBuilderTDSColumnState_.js';
+import { COLUMN_SORT_TYPE } from './QueryResultSetModifierState.js';
+
+export const findTDSColumnState = (
+  projectionState: QueryBuilderTDSState,
+  columnName: string,
+): QueryBuilderTDSColumnState | undefined =>
+  projectionState.tdsColumns.find((c) => c.columnName === columnName);
+
+export const getTDSColumnState = (
+  projectionState: QueryBuilderTDSState,
+  columnName: string,
+): QueryBuilderTDSColumnState =>
+  guaranteeNonNullable(
+    findTDSColumnState(projectionState, columnName),
+    `Column ${columnName} not found in TDS`,
+  );
+
+export const getTDSColSortTypeFromFunctionName = (
+  functionName: string,
+): COLUMN_SORT_TYPE => {
+  if (
+    matchFunctionName(functionName, QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_ASC)
+  ) {
+    return COLUMN_SORT_TYPE.ASC;
+  } else if (
+    matchFunctionName(functionName, QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_DESC)
+  ) {
+    return COLUMN_SORT_TYPE.DESC;
+  }
+  throw new UnsupportedOperationError(
+    `Unsupported TDS sort function: ${functionName}`,
+  );
+};
+
+export const getFunctionNameFromTDSSortColumn = (
+  columnSortType: COLUMN_SORT_TYPE,
+): string => {
+  switch (columnSortType) {
+    case COLUMN_SORT_TYPE.ASC:
+      return extractElementNameFromPath(
+        QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_ASC,
+      );
+    case COLUMN_SORT_TYPE.DESC:
+      return extractElementNameFromPath(
+        QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_DESC,
+      );
+    default:
+      throw new UnsupportedOperationError(
+        `Unsupported column sort type ${columnSortType}`,
+      );
+  }
+};

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

@@ -56,7 +56,10 @@ import {
   DEFAULT_LAMBDA_VARIABLE_NAME,
   QUERY_BUILDER_SOURCE_ID_LABEL,
 } from '../../QueryBuilderConfig.js';
-import { QueryBuilderAggregationState } from './aggregation/QueryBuilderAggregationState.js';
+import {
+  QueryBuilderAggregateColumnState,
+  QueryBuilderAggregationState,
+} from './aggregation/QueryBuilderAggregationState.js';
 import { buildGenericLambdaFunctionInstanceValue } from '../../QueryBuilderValueSpecificationHelper.js';
 import {
   FETCH_STRUCTURE_IMPLEMENTATION,
@@ -88,6 +91,10 @@ 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 { QueryBuilderTDSOlapOperator } from './olapGroupBy/operators/QueryBuilderTDSOlapOperator_.js';
+import { getQueryBuilderCoreOlapGroupByOperators } from './olapGroupBy/QueryBuilderOlapGroupByOperatorLoader.js';
+import type { QueryBuilderTDSColumnState } from './QueryBuilderTDSColumnState_.js';
 
 export class QueryBuilderTDSState
   extends QueryBuilderFetchStructureImplementationState
@@ -95,15 +102,19 @@ export class QueryBuilderTDSState
 {
   readonly aggregationState: QueryBuilderAggregationState;
   readonly postFilterState: QueryBuilderPostFilterState;
+  readonly olapGroupByState: QueryBuilderOlapGroupByState;
   readonly resultSetModifierState: QueryResultSetModifierState;
   projectionColumns: QueryBuilderProjectionColumnState[] = [];
   isConvertDerivationProjectionObjects = false;
   showPostFilterPanel = false;
+  showOlapGroupByPanel = false;
 
   postFilterOperators: QueryBuilderPostFilterOperator[] =
     getQueryBuilderCorePostFilterOperators();
   aggregationOperators: QueryBuilderAggregateOperator[] =
     getQueryBuilderCoreAggregrationOperators();
+  olapGroupByOperators: QueryBuilderTDSOlapOperator[] =
+    getQueryBuilderCoreOlapGroupByOperators();
 
   constructor(
     queryBuilderState: QueryBuilderState,
@@ -115,12 +126,15 @@ export class QueryBuilderTDSState
       projectionColumns: observable,
       isConvertDerivationProjectionObjects: observable,
       showPostFilterPanel: observable,
+      showOlapGroupByPanel: observable,
+      TEMPORARY__showPostFetchStructurePanel: computed,
       derivations: computed,
       hasParserError: computed,
       addColumn: action,
       moveColumn: action,
       replaceColumn: action,
       setShowPostFilterPanel: action,
+      setShowOlapGroupByPanel: action,
       convertDerivationProjectionObjects: flow,
     });
 
@@ -133,6 +147,10 @@ export class QueryBuilderTDSState
       this,
       this.aggregationOperators,
     );
+    this.olapGroupByState = new QueryBuilderOlapGroupByState(
+      this,
+      this.olapGroupByOperators,
+    );
   }
 
   get type(): string {
@@ -151,6 +169,14 @@ export class QueryBuilderTDSState
     );
   }
 
+  override get TEMPORARY__showPostFetchStructurePanel(): boolean {
+    return (
+      this.queryBuilderState.filterState.showPanel ||
+      this.showOlapGroupByPanel ||
+      this.showPostFilterPanel
+    );
+  }
+
   get usedExplorerTreePropertyNodeIDs(): string[] {
     let nodeIDs: string[] = [];
     this.projectionColumns.forEach((column) => {
@@ -241,6 +267,43 @@ export class QueryBuilderTDSState
     return undefined;
   }
 
+  get tdsColumns(): QueryBuilderTDSColumnState[] {
+    const aggregationStateCols = this.aggregationState.columns.map(
+      (c) => c.projectionColumnState,
+    );
+    // remove projection columns in aggregation
+    const projectionColumns = this.projectionColumns.filter(
+      (c) => !aggregationStateCols.includes(c),
+    );
+    return [
+      ...this.aggregationState.columns,
+      ...projectionColumns,
+      ...this.olapGroupByState.olapColumns,
+    ];
+  }
+
+  isDuplicateColumn(col: QueryBuilderTDSColumnState): boolean {
+    return (
+      this.tdsColumns.filter((c) => c.columnName === col.columnName).length > 1
+    );
+  }
+
+  isColumnInUse(tdsCol: QueryBuilderTDSColumnState): boolean {
+    return Boolean(
+      [
+        ...this.postFilterState.referencedTDSColumns,
+        ...this.olapGroupByState.referencedTDSColumns,
+      ].find((col) => {
+        if (col instanceof QueryBuilderAggregateColumnState) {
+          return tdsCol instanceof QueryBuilderAggregateColumnState
+            ? tdsCol === col
+            : col.projectionColumnState === tdsCol;
+        }
+        return col === tdsCol;
+      }),
+    );
+  }
+
   onClassChange(_class: Class | undefined): void {
     return;
   }
@@ -256,6 +319,10 @@ export class QueryBuilderTDSState
     this.showPostFilterPanel = val;
   }
 
+  setShowOlapGroupByPanel(val: boolean): void {
+    this.showOlapGroupByPanel = val;
+  }
+
   *convertDerivationProjectionObjects(): GeneratorFn<void> {
     const lambdas = new Map<string, RawLambda>();
     const derivationProjectionColumnStateMap = new Map<

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

@@ -26,8 +26,8 @@ import {
 import { QUERY_BUILDER_HASH_STRUCTURE } from '../../../graphManager/QueryBuilderHashUtils.js';
 
 export enum COLUMN_SORT_TYPE {
-  ASC,
-  DESC,
+  ASC = 'ASC',
+  DESC = 'DESC',
 }
 
 export class SortColumnState implements Hashable {

package/src/stores/fetch-structure/tds/aggregation/QueryBuilderAggregateOperator.ts

@@ -84,7 +84,7 @@ export abstract class QueryBuilderAggregateOperator implements Hashable {
    */
   getReturnType(aggregateColumnState: QueryBuilderAggregateColumnState): Type {
     return guaranteeNonNullable(
-      aggregateColumnState.projectionColumnState.getReturnType(),
+      aggregateColumnState.projectionColumnState.getColumnType(),
     );
   }
 

package/src/stores/fetch-structure/tds/aggregation/QueryBuilderAggregationState.ts

@@ -16,7 +16,6 @@
 
 import { action, computed, makeObservable, observable } from 'mobx';
 import {
-  uuid,
   deleteEntry,
   addUniqueEntry,
   type Hashable,
@@ -28,9 +27,12 @@ import type { QueryBuilderTDSState } from '../QueryBuilderTDSState.js';
 import type { QueryBuilderAggregateOperator } from './QueryBuilderAggregateOperator.js';
 import type { QueryBuilderProjectionColumnState } from '../projection/QueryBuilderProjectionColumnState.js';
 import { QUERY_BUILDER_HASH_STRUCTURE } from '../../../../graphManager/QueryBuilderHashUtils.js';
+import { QueryBuilderTDSColumnState } from '../QueryBuilderTDSColumnState_.js';
 
-export class QueryBuilderAggregateColumnState implements Hashable {
-  readonly uuid = uuid();
+export class QueryBuilderAggregateColumnState
+  extends QueryBuilderTDSColumnState
+  implements Hashable
+{
   readonly aggregationState: QueryBuilderAggregationState;
   projectionColumnState: QueryBuilderProjectionColumnState;
   lambdaParameterName: string = DEFAULT_LAMBDA_VARIABLE_NAME;
@@ -41,6 +43,7 @@ export class QueryBuilderAggregateColumnState implements Hashable {
     projectionColumnState: QueryBuilderProjectionColumnState,
     operator: QueryBuilderAggregateOperator,
   ) {
+    super();
     makeObservable(this, {
       projectionColumnState: observable,
       lambdaParameterName: observable,
@@ -55,11 +58,6 @@ export class QueryBuilderAggregateColumnState implements Hashable {
     this.projectionColumnState = projectionColumnState;
     this.operator = operator;
   }
-
-  get columnName(): string {
-    return this.projectionColumnState.columnName;
-  }
-
   setColumnState(val: QueryBuilderProjectionColumnState): void {
     this.projectionColumnState = val;
   }
@@ -72,7 +70,7 @@ export class QueryBuilderAggregateColumnState implements Hashable {
     this.operator = val;
   }
 
-  getReturnType(): Type {
+  getColumnType(): Type {
     return this.operator.getReturnType(this);
   }
 
@@ -82,6 +80,10 @@ export class QueryBuilderAggregateColumnState implements Hashable {
       this.operator,
     ]);
   }
+
+  get columnName(): string {
+    return this.projectionColumnState.columnName;
+  }
 }
 
 export class QueryBuilderAggregationState implements Hashable {

package/src/stores/fetch-structure/tds/olapGroupBy/QueryBuilderOlapGroupByOperatorLoader.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 { QueryBuilderTDSOlapOperator } from './operators/QueryBuilderTDSOlapOperator_.js';
+import { QueryBuilderTDSOlapRankOperator_AverageRank } from './operators/QueryBuilderTDSOlapRankOperator_AverageRank_.js';
+import { QueryBuilderTDSOlapRankOperator_DenseRank } from './operators/QueryBuilderTDSOlapRankOperator_DenseRank_.js';
+import { QueryBuilderTDSOlapRankOperator_Rank } from './operators/QueryBuilderTDSOlapRankOperator_Rank_.js';
+import { QueryBuilderTDSOlapRankOperator_RowNumber } from './operators/QueryBuilderTDSOlapRankOperator_RowNumber_.js';
+import { QueryBuilderTDSOlapOperator_Sum } from './operators/QueryBuilderTDSOlapOperator_Sum.js';
+import { QueryBuilderTDSOlapOperator_Count } from './operators/QueryBuilderTDSOlapOperator_Count.js';
+import { QueryBuilderTDSOlapOperator_Max } from './operators/QueryBuilderTDSOlapOperator_Max.js';
+import { QueryBuilderTDSOlapOperator_Min } from './operators/QueryBuilderTDSOlapOperator_Min.js';
+import { QueryBuilderTDSOlapOperator_Average } from './operators/QueryBuilderTDSOlapOperator_Average.js';
+
+export const getQueryBuilderCoreOlapGroupByOperators =
+  (): QueryBuilderTDSOlapOperator[] => [
+    new QueryBuilderTDSOlapOperator_Sum(),
+    new QueryBuilderTDSOlapOperator_Count(),
+    new QueryBuilderTDSOlapOperator_Max(),
+    new QueryBuilderTDSOlapOperator_Min(),
+    new QueryBuilderTDSOlapOperator_Average(),
+    new QueryBuilderTDSOlapRankOperator_AverageRank(),
+    new QueryBuilderTDSOlapRankOperator_DenseRank(),
+    new QueryBuilderTDSOlapRankOperator_Rank(),
+    new QueryBuilderTDSOlapRankOperator_RowNumber(),
+  ];