@finos/legend-query-builder 4.17.99 → 4.18.0

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

@@ -19,9 +19,14 @@ import {
   SimpleFunctionExpression,
   matchFunctionName,
   ColSpecArrayInstance,
+  AccessorInstanceValue,
 } from '@finos/legend-graph';
 import { FETCH_STRUCTURE_IMPLEMENTATION } from '../../QueryBuilderFetchStructureImplementationState.js';
-import { assertTrue, assertType, guaranteeType } from '@finos/legend-shared';
+import {
+  assertTrue,
+  assertType,
+  guaranteeNonNullable,
+} from '@finos/legend-shared';
 import {
   QUERY_BUILDER_LAMBDA_WRITER_MODE,
   type QueryBuilderState,
@@ -47,24 +52,28 @@ export const processTypedTDSProjectExpression = (
     FETCH_STRUCTURE_IMPLEMENTATION.TABULAR_DATA_STRUCTURE,
   );
 
-  // check preceding expression
-  const precedingExpression = guaranteeType(
+  const _precedingExpression = guaranteeNonNullable(
     expression.parametersValues[0],
-    SimpleFunctionExpression,
-    `Can't process typed project() expression: only support typed project() immediately following an expression`,
-  );
-  assertTrue(
-    matchFunctionName(precedingExpression.functionName, [
-      QUERY_BUILDER_SUPPORTED_GET_ALL_FUNCTIONS.GET_ALL,
-      QUERY_BUILDER_SUPPORTED_GET_ALL_FUNCTIONS.GET_ALL_VERSIONS,
-      QUERY_BUILDER_SUPPORTED_GET_ALL_FUNCTIONS.GET_ALL_VERSIONS_IN_RANGE,
-      QUERY_BUILDER_SUPPORTED_FUNCTIONS.FILTER,
-      QUERY_BUILDER_SUPPORTED_FUNCTIONS.WATERMARK,
-    ]),
-    `Can't process typed project() expression: only support typed project() immediately following either getAll(), filter(), or forWatermark()`,
+    `Can't process typed project() expression: missing preceding expression`,
   );
+  if (_precedingExpression instanceof SimpleFunctionExpression) {
+    assertTrue(
+      matchFunctionName(_precedingExpression.functionName, [
+        QUERY_BUILDER_SUPPORTED_GET_ALL_FUNCTIONS.GET_ALL,
+        QUERY_BUILDER_SUPPORTED_GET_ALL_FUNCTIONS.GET_ALL_VERSIONS,
+        QUERY_BUILDER_SUPPORTED_GET_ALL_FUNCTIONS.GET_ALL_VERSIONS_IN_RANGE,
+        QUERY_BUILDER_SUPPORTED_FUNCTIONS.FILTER,
+        QUERY_BUILDER_SUPPORTED_FUNCTIONS.WATERMARK,
+      ]),
+      `Can't process typed project() expression: only support typed project() immediately following either getAll(), filter(), or forWatermark()`,
+    );
+  } else if (!(_precedingExpression instanceof AccessorInstanceValue)) {
+    throw new Error(
+      `Can't process typed project() expression: the first argument is expected to be either a function expression or a Accessor Instance Value`,
+    );
+  }
   QueryBuilderValueSpecificationProcessor.process(
-    precedingExpression,
+    _precedingExpression,
     parentLambda,
     queryBuilderState,
   );

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

@@ -85,7 +85,7 @@ export class WindowGroupByColumnSortByState implements Hashable {
 
 export abstract class QueryBuilderTDS_WindowOperatorState implements Hashable {
   readonly windowState: QueryBuilderWindowState;
-  lambdaParameterName: string = DEFAULT_LAMBDA_VARIABLE_NAME;
+  lambdaParameterNames: string[] = [DEFAULT_LAMBDA_VARIABLE_NAME];
   operator: QueryBuilderTDS_WindowOperator;
 
   constructor(
@@ -96,8 +96,12 @@ export abstract class QueryBuilderTDS_WindowOperatorState implements Hashable {
     this.operator = operator;
   }
 
-  setLambdaParameterName(paramName: string): void {
-    this.lambdaParameterName = paramName;
+  setLambdaParameterNames(paramNames: string[]): void {
+    this.lambdaParameterNames = paramNames;
+  }
+
+  addParameterName(paramName: string): void {
+    this.lambdaParameterNames.push(paramName);
   }
 
   setOperator(val: QueryBuilderTDS_WindowOperator): void {
@@ -107,7 +111,7 @@ export abstract class QueryBuilderTDS_WindowOperatorState implements Hashable {
   get hashCode(): string {
     return hashArray([
       QUERY_BUILDER_STATE_HASH_STRUCTURE.TDS_WINDOW_GROUPBY_OPERATION_STATE,
-      this.lambdaParameterName,
+      hashArray(this.lambdaParameterNames),
       this.operator,
     ]);
   }
@@ -120,7 +124,7 @@ export class QueryBuilderTDS_WindowRankOperatorState extends QueryBuilderTDS_Win
   ) {
     super(windowState, operator);
     makeObservable(this, {
-      setLambdaParameterName: action,
+      setLambdaParameterNames: action,
     });
   }
 }
@@ -136,7 +140,7 @@ export class QueryBuilderTDS_WindowAggreationOperatorState extends QueryBuilderT
     makeObservable(this, {
       columnState: observable,
       setColumnState: action,
-      setLambdaParameterName: action,
+      setLambdaParameterNames: action,
     });
     this.columnState = columnState;
   }
@@ -148,7 +152,7 @@ export class QueryBuilderTDS_WindowAggreationOperatorState extends QueryBuilderT
   override get hashCode(): string {
     return hashArray([
       QUERY_BUILDER_STATE_HASH_STRUCTURE.TDS_WINDOW_GROUPBY_AGG_OPERATOR_STATE,
-      this.lambdaParameterName,
+      hashArray(this.lambdaParameterNames),
       this.operator,
       this.columnState.columnName,
     ]);
@@ -446,8 +450,18 @@ export class QueryBuilderWindowState implements Hashable {
     this.editColumn = col;
   }
 
-  findOperator(func: string): QueryBuilderTDS_WindowOperator | undefined {
-    return this.operators.find((o) => matchFunctionName(func, o.pureFunc));
+  findOperator(
+    func: string,
+    typed?: boolean,
+  ): QueryBuilderTDS_WindowOperator | undefined {
+    return this.operators.find((operator) => {
+      const operatorFunction = typed
+        ? operator.relationFunc
+        : operator.pureFunc;
+      return operatorFunction
+        ? matchFunctionName(func, operatorFunction)
+        : undefined;
+    });
   }
 
   addWindowColumn(windowCol: QueryBuilderWindowColumnState): void {

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

@@ -16,6 +16,9 @@
 
 import {
   CollectionInstanceValue,
+  type ColSpec,
+  ColSpecArrayInstance,
+  ColSpecInstanceValue,
   LambdaFunction,
   LambdaFunctionInstanceValue,
   matchFunctionName,
@@ -29,6 +32,7 @@ import {
   guaranteeIsString,
   guaranteeNonNullable,
   guaranteeType,
+  UnsupportedOperationError,
 } from '@finos/legend-shared';
 import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../../graph/QueryBuilderMetaModelConst.js';
 import type { QueryBuilderState } from '../../../QueryBuilderState.js';
@@ -36,6 +40,7 @@ import { QueryBuilderValueSpecificationProcessor } from '../../../QueryBuilderSt
 import {
   getTDSColumnState,
   getTDSColSortTypeFromFunctionName,
+  getRelationSortColumnFromFunctionName,
 } from '../QueryBuilderTDSHelper.js';
 import { QueryBuilderTDSState } from '../QueryBuilderTDSState.js';
 import {
@@ -45,6 +50,7 @@ import {
   QueryBuilderTDS_WindowAggreationOperatorState,
   QueryBuilderTDS_WindowRankOperatorState,
 } from './QueryBuilderWindowState.js';
+import type { QueryBuilderTDSColumnState } from '../QueryBuilderTDSColumnState.js';
 
 export const processTDS_OLAPGroupByExpression = (
   expression: SimpleFunctionExpression,
@@ -179,13 +185,13 @@ export const processTDS_OLAPGroupByExpression = (
       operation,
       oppColumnState,
     );
-    operatorState.setLambdaParameterName(
+    operatorState.setLambdaParameterNames([
       guaranteeType(
         operationLambda.functionType.parameters[0],
         VariableExpression,
         `Can't process olapGroupBy() operation lambda: only support olapGroupBy() operation lambda with 1 parameter of type 'VariableExpression'`,
       ).name,
-    );
+    ]);
   } else {
     const operationLambda = guaranteeType(
       guaranteeType(olapOperationExpression, LambdaFunctionInstanceValue)
@@ -209,13 +215,13 @@ export const processTDS_OLAPGroupByExpression = (
       tdsState.windowState,
       operation,
     );
-    operatorState.setLambdaParameterName(
+    operatorState.setLambdaParameterNames([
       guaranteeType(
         operationLambda.functionType.parameters[0],
         VariableExpression,
         `Can't process olapGroupBy() operation lambda: only support olapGroupBy() operation lambda with 1 parameter of type 'VariableExpression'`,
       ).name,
-    );
+    ]);
   }
 
   // main col
@@ -237,3 +243,139 @@ export const processTDS_OLAPGroupByExpression = (
   tdsState.windowState.addWindowColumn(olapGroupByColumnState);
   tdsState.setShowWindowFuncPanel(true);
 };
+
+const process_WindowOperatorState = (
+  colSpec: ColSpec,
+  tdsState: QueryBuilderTDSState,
+): QueryBuilderTDS_WindowOperatorState => {
+  //TODO: handle aggregation operators
+  const rankLambda = guaranteeType(
+    guaranteeType(colSpec.function1, LambdaFunctionInstanceValue).values[0],
+    LambdaFunction,
+  );
+  assertTrue(rankLambda.expressionSequence.length === 1);
+  const operationFunctionExp = guaranteeType(
+    rankLambda.expressionSequence[0],
+    SimpleFunctionExpression,
+  );
+
+  const operation = guaranteeNonNullable(
+    tdsState.windowState.findOperator(operationFunctionExp.functionName, true),
+    `Operator '${operationFunctionExp.functionName}' not supported yet for typed TDS`,
+  );
+
+  const operatorState = new QueryBuilderTDS_WindowRankOperatorState(
+    tdsState.windowState,
+    operation,
+  );
+
+  const operatorParameters: string[] = [];
+  rankLambda.functionType.parameters.forEach((param) => {
+    guaranteeType(param, VariableExpression);
+    operatorParameters.push(param.name);
+  });
+  operatorState.setLambdaParameterNames(operatorParameters);
+
+  return operatorState;
+};
+
+export const processTDS_ExtendExpression = (
+  expression: SimpleFunctionExpression,
+  queryBuilderState: QueryBuilderState,
+  parentLambda: LambdaFunction,
+): void => {
+  if (expression.parametersValues.length === 3) {
+    const relationExpression = guaranteeType(
+      expression.parametersValues[0],
+      SimpleFunctionExpression,
+      `Can't process extend() expression: only support extend() immediately following an expression`,
+    );
+    QueryBuilderValueSpecificationProcessor.process(
+      relationExpression,
+      parentLambda,
+      queryBuilderState,
+    );
+
+    const windowExpression = guaranteeType(
+      expression.parametersValues[1],
+      SimpleFunctionExpression,
+      `Can't process extend() expression: expects a window expression as the second parameter`,
+    );
+
+    const tdsState = guaranteeType(
+      queryBuilderState.fetchStructureState.implementation,
+      QueryBuilderTDSState,
+    );
+    //TODO: handle over() with ColSpec as the first parameter
+    const windowColumnsSpec = guaranteeType(
+      windowExpression.parametersValues[0],
+      ColSpecArrayInstance,
+      `Can't process over(): expects ColSpecArray for window columns`,
+    );
+
+    const windowColSpecArray = guaranteeNonNullable(
+      windowColumnsSpec.values[0],
+    );
+    const windowColumns: QueryBuilderTDSColumnState[] =
+      windowColSpecArray.colSpecs.map((colSpec) =>
+        getTDSColumnState(tdsState, colSpec.name),
+      );
+
+    let sortByState: WindowGroupByColumnSortByState | undefined;
+    if (
+      windowExpression.parametersValues[1] instanceof CollectionInstanceValue
+    ) {
+      const sortByExpression = guaranteeType(
+        windowExpression.parametersValues[1].values[0],
+        SimpleFunctionExpression,
+        `Can't process extend sortBy expression: only support function expression of 'ascending' or 'descending'`,
+      );
+
+      const sortByFunctionName = sortByExpression.functionName;
+      const colSortType =
+        getRelationSortColumnFromFunctionName(sortByFunctionName);
+      const colSortVal = guaranteeIsString(
+        guaranteeType(
+          sortByExpression.parametersValues[0],
+          ColSpecInstanceValue,
+          'Can`t process extend sort column : extend sort column should be a colspec instance value',
+        ).values[0]?.name,
+        'Can`t process extend sort column: extend sort column should be a string colspec instance value',
+      );
+      const sortColState = getTDSColumnState(tdsState, colSortVal);
+      sortByState = new WindowGroupByColumnSortByState(
+        sortColState,
+        colSortType,
+      );
+    }
+
+    //process third extend() parameter
+    const operatorColSpecInstance = guaranteeType(
+      expression.parametersValues[2],
+      ColSpecArrayInstance,
+      `Can't process extend(): expects ColSpecArrayInstance for aggregation columns`,
+    );
+    const operatorColSpecArray = guaranteeNonNullable(
+      operatorColSpecInstance.values[0],
+    );
+
+    operatorColSpecArray.colSpecs.forEach((colSpec) => {
+      const operatorState = process_WindowOperatorState(colSpec, tdsState);
+
+      const windowColumnState = new QueryBuilderWindowColumnState(
+        tdsState.windowState,
+        windowColumns,
+        sortByState,
+        operatorState,
+        colSpec.name,
+      );
+
+      tdsState.windowState.addWindowColumn(windowColumnState);
+      tdsState.setShowWindowFuncPanel(true);
+    });
+  } else {
+    throw new UnsupportedOperationError(
+      `Can't build relation extend() expression: extend() is not fully supported yet`,
+    );
+  }
+};

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

@@ -25,16 +25,29 @@ import {
   VariableExpression,
   Multiplicity,
   PrimitiveType,
+  ColSpec,
+  ColSpecArray,
+  ColSpecArrayInstance,
+  ColSpecInstanceValue,
 } from '@finos/legend-graph';
 import { guaranteeNonNullable } from '@finos/legend-shared';
 import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../../graph/QueryBuilderMetaModelConst.js';
 import { buildGenericLambdaFunctionInstanceValue } from '../../../QueryBuilderValueSpecificationHelper.js';
-import { getFunctionNameFromTDSSortColumn } from '../QueryBuilderTDSHelper.js';
+import {
+  getFunctionNameFromTDSSortColumn,
+  getFunctionNameFromRelationSortColumn,
+} from '../QueryBuilderTDSHelper.js';
 import {
   type QueryBuilderWindowColumnState,
   type QueryBuilderWindowState,
   QueryBuilderTDS_WindowAggreationOperatorState,
 } from './QueryBuilderWindowState.js';
+import { DEFAULT_LAMBDA_VARIABLE_NAME } from '@finos/legend-data-cube';
+import {
+  DEFAULT_WINDOW_FUNCTION_PARTITION_VAR_NAME,
+  DEFAULT_WINDOW_FUNCTION_ROW_VAR_NAME,
+  DEFAULT_WINDOW_FUNCTION_WINDOW_VAR_NAME,
+} from '../../../QueryBuilderConfig.js';
 
 const appendOLAPGroupByColumnState = (
   olapGroupByColumnState: QueryBuilderWindowColumnState,
@@ -78,16 +91,15 @@ const appendOLAPGroupByColumnState = (
 
   // create olap operation expression
   const operationState = olapGroupByColumnState.operatorState;
+  const lambdaParameterName =
+    operationState.lambdaParameterNames[0] ?? DEFAULT_LAMBDA_VARIABLE_NAME;
   const olapFunc = extractElementNameFromPath(operationState.operator.pureFunc);
   const olapFuncExpression = new SimpleFunctionExpression(olapFunc);
   olapFuncExpression.parametersValues = [
-    new VariableExpression(
-      operationState.lambdaParameterName,
-      Multiplicity.ONE,
-    ),
+    new VariableExpression(lambdaParameterName, Multiplicity.ONE),
   ];
   const olapLambdaFuncInstance = buildGenericLambdaFunctionInstanceValue(
-    operationState.lambdaParameterName,
+    lambdaParameterName,
     [olapFuncExpression],
     graph,
   );
@@ -132,12 +144,135 @@ const appendOLAPGroupByColumnState = (
   return lambda;
 };
 
-export const appendOLAPGroupByState = (
-  olapGroupByState: QueryBuilderWindowState,
+export const appendOverExpression = (
+  extendColumnState: QueryBuilderWindowColumnState,
+): SimpleFunctionExpression => {
+  const overExpression = new SimpleFunctionExpression(
+    extractElementNameFromPath(QUERY_BUILDER_SUPPORTED_FUNCTIONS.RELATION_OVER),
+  );
+
+  //TODO: handle over() where the first parameter is a ColSpec
+  const colSpecArrayInstance = new ColSpecArrayInstance(
+    Multiplicity.ONE,
+    undefined,
+  );
+  const colSpecArray = new ColSpecArray();
+  colSpecArrayInstance.values = [colSpecArray];
+
+  extendColumnState.windowColumns.forEach((column) => {
+    const colSpec = new ColSpec();
+    colSpec.name = column.columnName;
+    colSpecArray.colSpecs.push(colSpec);
+  });
+  overExpression.parametersValues.push(colSpecArrayInstance);
+
+  if (extendColumnState.sortByState) {
+    const sortByState = extendColumnState.sortByState;
+    const sortByFunction = new SimpleFunctionExpression(
+      getFunctionNameFromRelationSortColumn(sortByState.sortType),
+    );
+    const sortColSpec = new ColSpecInstanceValue(Multiplicity.ONE, undefined);
+    const sortCol = new ColSpec();
+    sortCol.name = sortByState.columnState.columnName;
+    sortColSpec.values = [sortCol];
+    sortByFunction.parametersValues[0] = sortColSpec;
+
+    const sortByCollection = new CollectionInstanceValue(Multiplicity.ONE);
+    sortByCollection.values = [sortByFunction];
+
+    overExpression.parametersValues.push(sortByCollection);
+  }
+
+  return overExpression;
+};
+
+const appendExtendColumnState = (
+  extendColumnState: QueryBuilderWindowColumnState,
   lambda: LambdaFunction,
 ): LambdaFunction => {
-  olapGroupByState.windowColumns.forEach((c) =>
-    appendOLAPGroupByColumnState(c, lambda),
+  const graph =
+    extendColumnState.windowState.tdsState.queryBuilderState.graphManagerState
+      .graph;
+
+  const overExpression = appendOverExpression(extendColumnState);
+
+  const operatorColSpecArrayInst = new ColSpecArrayInstance(
+    Multiplicity.ONE,
+    undefined,
+  );
+  const operatorColSpecArray = new ColSpecArray();
+  operatorColSpecArrayInst.values = [operatorColSpecArray];
+
+  const operatorColSpec = new ColSpec();
+  operatorColSpec.name = extendColumnState.columnName;
+
+  const operatorState = extendColumnState.operatorState;
+  if (operatorState.lambdaParameterNames.length === 1) {
+    //this was previously nontyped, so need to add window function parameters
+    operatorState.setLambdaParameterNames([
+      DEFAULT_WINDOW_FUNCTION_PARTITION_VAR_NAME,
+      DEFAULT_WINDOW_FUNCTION_WINDOW_VAR_NAME,
+      DEFAULT_WINDOW_FUNCTION_ROW_VAR_NAME,
+    ]);
+  }
+
+  //TODO: handle aggregation operators
+  const operatorFunc = extractElementNameFromPath(
+    operatorState.operator.pureFunc,
+  );
+  const operatorFuncExpression = new SimpleFunctionExpression(operatorFunc);
+
+  const lambdaParameters: VariableExpression[] = [];
+  operatorState.lambdaParameterNames.forEach((paramName) => {
+    lambdaParameters.push(new VariableExpression(paramName, Multiplicity.ONE));
+  });
+  operatorFuncExpression.parametersValues = lambdaParameters;
+
+  const rankLambda = buildGenericLambdaFunctionInstanceValue(
+    operatorState.lambdaParameterNames[0] ??
+      DEFAULT_WINDOW_FUNCTION_PARTITION_VAR_NAME,
+    [operatorFuncExpression],
+    graph,
   );
+
+  //skip over the first parameter since it was added in buildGenericLambdaFunctionInstanceValue()
+  lambdaParameters.slice(1).forEach((param) => {
+    rankLambda.values[0]?.functionType.parameters.push(param);
+  });
+  operatorColSpec.function1 = rankLambda;
+  operatorColSpecArray.colSpecs.push(operatorColSpec);
+
+  const extendExpression = new SimpleFunctionExpression(
+    extractElementNameFromPath(
+      QUERY_BUILDER_SUPPORTED_FUNCTIONS.RELATION_EXTEND,
+    ),
+  );
+
+  const currentExpression = guaranteeNonNullable(lambda.expressionSequence[0]);
+  extendExpression.parametersValues = [
+    currentExpression,
+    overExpression,
+    operatorColSpecArrayInst,
+  ];
+
+  lambda.expressionSequence[0] = extendExpression;
+  return lambda;
+};
+
+export const appendWindowFunctionState = (
+  olapGroupByState: QueryBuilderWindowState,
+  lambda: LambdaFunction,
+): LambdaFunction => {
+  const typedTds =
+    olapGroupByState.tdsState.queryBuilderState.isFetchStructureTyped;
+  if (typedTds) {
+    olapGroupByState.windowColumns.forEach((c) =>
+      appendExtendColumnState(c, lambda),
+    );
+  } else {
+    olapGroupByState.windowColumns.forEach((c) =>
+      appendOLAPGroupByColumnState(c, lambda),
+    );
+  }
   return lambda;
 };

package/src/stores/fetch-structure/tds/window/operators/QueryBuilderTDS_WindowOperator.ts

@@ -27,6 +27,8 @@ export abstract class QueryBuilderTDS_WindowOperator implements Hashable {
 
   abstract get pureFunc(): string;
 
+  abstract get relationFunc(): string | undefined;
+
   abstract isCompatibleWithType(type: Type | undefined): boolean;
 
   isColumnAggregator(): boolean {

package/src/stores/fetch-structure/tds/window/operators/QueryBuilderTDS_WindowOperator_Average.ts

@@ -32,6 +32,10 @@ export class QueryBuilderTDS_WindowOperator_Average extends QueryBuilderTDS_Wind
     return QUERY_BUILDER_SUPPORTED_FUNCTIONS.AVERAGE;
   }
 
+  get relationFunc(): string | undefined {
+    return undefined;
+  }
+
   get hashCode(): string {
     return hashArray([
       QUERY_BUILDER_STATE_HASH_STRUCTURE.TDS_WINDOW_OPERATOR_AVERAGE,

package/src/stores/fetch-structure/tds/window/operators/QueryBuilderTDS_WindowOperator_Count.ts

@@ -32,6 +32,10 @@ export class QueryBuilderTDS_WindowOperator_Count extends QueryBuilderTDS_Window
     return QUERY_BUILDER_SUPPORTED_FUNCTIONS.COUNT;
   }
 
+  get relationFunc(): string | undefined {
+    return undefined;
+  }
+
   get hashCode(): string {
     return hashArray([
       QUERY_BUILDER_STATE_HASH_STRUCTURE.TDS_WINDOW_OPERATOR_COUNT,

package/src/stores/fetch-structure/tds/window/operators/QueryBuilderTDS_WindowOperator_Max.ts

@@ -32,6 +32,10 @@ export class QueryBuilderTDS_WindowOperator_Max extends QueryBuilderTDS_WindowOp
     return QUERY_BUILDER_SUPPORTED_FUNCTIONS.MAX;
   }
 
+  get relationFunc(): string | undefined {
+    return undefined;
+  }
+
   get hashCode(): string {
     return hashArray([
       QUERY_BUILDER_STATE_HASH_STRUCTURE.TDS_WINDOW_OPERATOR_MAX,

package/src/stores/fetch-structure/tds/window/operators/QueryBuilderTDS_WindowOperator_Min.ts

@@ -32,6 +32,10 @@ export class QueryBuilderTDS_WindowOperator_Min extends QueryBuilderTDS_WindowOp
     return QUERY_BUILDER_SUPPORTED_FUNCTIONS.MIN;
   }
 
+  get relationFunc(): string | undefined {
+    return undefined;
+  }
+
   get hashCode(): string {
     return hashArray([
       QUERY_BUILDER_STATE_HASH_STRUCTURE.TDS_WINDOW_OPERATOR_MIN,

package/src/stores/fetch-structure/tds/window/operators/QueryBuilderTDS_WindowOperator_Sum.ts

@@ -32,6 +32,10 @@ export class QueryBuilderTDS_WindowOperator_Sum extends QueryBuilderTDS_WindowOp
     return QUERY_BUILDER_SUPPORTED_FUNCTIONS.SUM;
   }
 
+  get relationFunc(): string | undefined {
+    return undefined;
+  }
+
   get hashCode(): string {
     return hashArray([
       QUERY_BUILDER_STATE_HASH_STRUCTURE.TDS_WINDOW_OPERATOR_SUM,

package/src/stores/fetch-structure/tds/window/operators/QueryBuilderTDS_WindowRankOperator_AverageRank.ts

@@ -29,6 +29,11 @@ export class QueryBuilderTDS_WindowRankOperator_AverageRank extends QueryBuilder
     return QUERY_BUILDER_SUPPORTED_FUNCTIONS.OLAP_AVERAGE_RANK;
   }
 
+  get relationFunc(): string | undefined {
+    //averageRank not supported for typed TDS
+    return undefined;
+  }
+
   get hashCode(): string {
     return hashArray([
       QUERY_BUILDER_STATE_HASH_STRUCTURE.TDS_WINDOW_OPERATOR_DENSE_RANK,

package/src/stores/fetch-structure/tds/window/operators/QueryBuilderTDS_WindowRankOperator_DenseRank.ts

@@ -29,6 +29,10 @@ export class QueryBuilderTDS_WindowRankOperator_DenseRank extends QueryBuilderTD
     return QUERY_BUILDER_SUPPORTED_FUNCTIONS.OLAP_DENSE_RANK;
   }
 
+  get relationFunc(): string | undefined {
+    return QUERY_BUILDER_SUPPORTED_FUNCTIONS.RELATION_DENSE_RANK;
+  }
+
   get hashCode(): string {
     return hashArray([
       QUERY_BUILDER_STATE_HASH_STRUCTURE.TDS_WINDOW_OPERATOR_DENSE_RANK,

package/src/stores/fetch-structure/tds/window/operators/QueryBuilderTDS_WindowRankOperator_Rank.ts

@@ -29,6 +29,10 @@ export class QueryBuilderTDS_WindowRankOperator_Rank extends QueryBuilderTDS_Win
     return QUERY_BUILDER_SUPPORTED_FUNCTIONS.OLAP_RANK;
   }
 
+  get relationFunc(): string | undefined {
+    return QUERY_BUILDER_SUPPORTED_FUNCTIONS.RELATION_RANK;
+  }
+
   get hashCode(): string {
     return hashArray([
       QUERY_BUILDER_STATE_HASH_STRUCTURE.TDS_WINDOW_OPERATOR_RANK,

package/src/stores/fetch-structure/tds/window/operators/QueryBuilderTDS_WindowRankOperator_RowNumber.ts

@@ -29,6 +29,10 @@ export class QueryBuilderTDS_WindowRankOperator_RowNumber extends QueryBuilderTD
     return QUERY_BUILDER_SUPPORTED_FUNCTIONS.OLAP_ROW_NUMBER;
   }
 
+  get relationFunc(): string | undefined {
+    return undefined;
+  }
+
   get hashCode(): string {
     return hashArray([
       QUERY_BUILDER_STATE_HASH_STRUCTURE.TDS_WINDOW_OPERATOR_ROW_NUMBER,