@finos/legend-query-builder 4.17.100 → 4.18.1

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

@@ -30,6 +30,8 @@ import {
   PrimitiveInstanceValue,
   LambdaFunctionInstanceValue,
   ColSpecInstanceValue,
+  type RelationColumn,
+  type FunctionExpression,
 } from '@finos/legend-graph';
 import {
   assertNonNullable,
@@ -56,6 +58,7 @@ import {
 import { FETCH_STRUCTURE_IMPLEMENTATION } from '../../QueryBuilderFetchStructureImplementationState.js';
 import {
   QueryBuilderDerivationProjectionColumnState,
+  QueryBuilderRelationColumnProjectionColumnState,
   QueryBuilderSimpleProjectionColumnState,
 } from './QueryBuilderProjectionColumnState.js';
 import { QueryBuilderTDSState } from '../QueryBuilderTDSState.js';
@@ -300,6 +303,33 @@ export const processTDSProjectionColumnPropertyExpression = (
   }
 };
 
+export const processTDSRelationColumn = (
+  parentExpression: FunctionExpression,
+  columnName: string | undefined,
+  col: RelationColumn,
+  queryBuilderState: QueryBuilderState,
+): void => {
+  if (
+    queryBuilderState.fetchStructureState.implementation instanceof
+    QueryBuilderTDSState
+  ) {
+    const tdsState = queryBuilderState.fetchStructureState.implementation;
+    const columnState = new QueryBuilderRelationColumnProjectionColumnState(
+      tdsState,
+      col,
+      false,
+    );
+    tdsState.addColumn(columnState, { skipSorting: true });
+    if (columnName) {
+      columnState.setColumnName(columnName);
+    }
+    const parameter = parentExpression.parametersValues[0];
+    if (parameter instanceof VariableExpression) {
+      columnState.setLambdaParameterName(parameter.name);
+    }
+  }
+};
+
 export const processTDSProjectionDerivationExpression = (
   value: INTERNAL__UnknownValueSpecification,
   columnName: string | undefined,

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

@@ -47,7 +47,7 @@ import {
   buildPropertyExpressionChain,
   type LambdaFunctionBuilderOption,
 } from '../../../QueryBuilderValueSpecificationBuilderHelper.js';
-import { appendOLAPGroupByState } from '../window/QueryBuilderWindowValueSpecificationBuilder.js';
+import { appendWindowFunctionState } from '../window/QueryBuilderWindowValueSpecificationBuilder.js';
 import { appendPostFilter } from '../post-filter/QueryBuilderPostFilterValueSpecificationBuilder.js';
 import { buildRelationProjection } from './QueryBuilderRelationProjectValueSpecBuilder.js';
 import { QueryBuilderAggregateOperator_Wavg } from '../aggregation/operators/QueryBuilderAggregateOperator_Wavg.js';
@@ -67,7 +67,7 @@ const buildProjectColFunc = (
     projectionColumnState instanceof QueryBuilderSimpleProjectionColumnState
   ) {
     columnLambda = buildGenericLambdaFunctionInstanceValue(
-      projectionColumnState.lambdaParameterName,
+      [projectionColumnState.lambdaParameterName],
       [
         buildPropertyExpressionChain(
           projectionColumnState.propertyExpressionState.propertyExpression,
@@ -172,7 +172,7 @@ export const appendProjection = (
         projectionColumnState instanceof QueryBuilderSimpleProjectionColumnState
       ) {
         columnLambda = buildGenericLambdaFunctionInstanceValue(
-          projectionColumnState.lambdaParameterName,
+          [projectionColumnState.lambdaParameterName],
           [
             buildPropertyExpressionChain(
               projectionColumnState.propertyExpressionState.propertyExpression,
@@ -222,7 +222,7 @@ export const appendProjection = (
           extractElementNameFromPath(QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_AGG),
         );
         const aggregateLambda = buildGenericLambdaFunctionInstanceValue(
-          aggregateColumnState.lambdaParameterName,
+          [aggregateColumnState.lambdaParameterName],
           [
             aggregateColumnState.operator.buildAggregateExpressionFromState(
               aggregateColumnState,
@@ -242,8 +242,10 @@ export const appendProjection = (
           aggregateCalendarLambdaState instanceof SimpleFunctionExpression
         ) {
           aggregateCalendarLambda = buildGenericLambdaFunctionInstanceValue(
-            guaranteeNonNullable(aggregateColumnState.calendarFunction)
-              .lambdaParameterName,
+            [
+              guaranteeNonNullable(aggregateColumnState.calendarFunction)
+                .lambdaParameterName,
+            ],
             [aggregateCalendarLambdaState],
             aggregateColumnState.aggregationState.tdsState.queryBuilderState
               .graphManagerState.graph,
@@ -295,7 +297,7 @@ export const appendProjection = (
     ];
     lambdaFunction.expressionSequence[0] = groupByFunction;
   } else if (tdsState.projectionColumns.length) {
-    if (!tdsState.queryBuilderState.isFetchStructureTyped) {
+    if (!queryBuilderState.useRelation) {
       // projection
       const projectFunction = new SimpleFunctionExpression(
         extractElementNameFromPath(
@@ -348,7 +350,7 @@ export const appendProjection = (
             QueryBuilderSimpleProjectionColumnState
           ) {
             columnLambda = buildGenericLambdaFunctionInstanceValue(
-              projectionColumnState.lambdaParameterName,
+              [projectionColumnState.lambdaParameterName],
               [
                 buildPropertyExpressionChain(
                   projectionColumnState.propertyExpressionState
@@ -409,7 +411,7 @@ export const appendProjection = (
     }
   }
   // build olapGroupBy
-  appendOLAPGroupByState(tdsState.windowState, lambdaFunction);
+  appendWindowFunctionState(tdsState.windowState, lambdaFunction);
 
   // build post-filter
   appendPostFilter(tdsState.postFilterState, lambdaFunction);

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

@@ -31,10 +31,13 @@ import {
   Relation,
   RelationColumn,
   RelationType,
+  VariableExpression,
+  FunctionExpression,
 } from '@finos/legend-graph';
 import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../../graph/QueryBuilderMetaModelConst.js';
 import {
   QueryBuilderDerivationProjectionColumnState,
+  QueryBuilderRelationColumnProjectionColumnState,
   QueryBuilderSimpleProjectionColumnState,
 } from './QueryBuilderProjectionColumnState.js';
 import type { QueryBuilderTDSState } from '../QueryBuilderTDSState.js';
@@ -76,7 +79,7 @@ export const buildRelationProjection = (
       projectionColumnState instanceof QueryBuilderSimpleProjectionColumnState
     ) {
       columnLambda = buildGenericLambdaFunctionInstanceValue(
-        projectionColumnState.lambdaParameterName,
+        [projectionColumnState.lambdaParameterName],
         [
           buildPropertyExpressionChain(
             projectionColumnState.propertyExpressionState.propertyExpression,
@@ -87,6 +90,24 @@ export const buildRelationProjection = (
         ],
         queryBuilderState.graphManagerState.graph,
       );
+    } else if (
+      projectionColumnState instanceof
+      QueryBuilderRelationColumnProjectionColumnState
+    ) {
+      const real = projectionColumnState.column;
+      const simple = new FunctionExpression(real.name);
+      const variable = new VariableExpression(
+        projectionColumnState.lambdaParameterName,
+        Multiplicity.ONE,
+        undefined,
+      );
+      simple.func = real;
+      simple.parametersValues = [variable];
+      columnLambda = buildGenericLambdaFunctionInstanceValue(
+        [projectionColumnState.lambdaParameterName],
+        [simple],
+        queryBuilderState.graphManagerState.graph,
+      );
     } else if (
       projectionColumnState instanceof
       QueryBuilderDerivationProjectionColumnState

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/QueryBuilderWindowGroupByOperatorLoader.ts

@@ -24,6 +24,7 @@ import { QueryBuilderTDS_WindowOperator_Count } from './operators/QueryBuilderTD
 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';
+import { QueryBuilderTDS_WindowRankOperator_PercentRank } from './operators/QueryBuilderTDS_WindowOperator_PercentRank.js';
 
 export const getQueryBuilderCoreWindowOperators =
   (): QueryBuilderTDS_WindowOperator[] => [
@@ -36,4 +37,5 @@ export const getQueryBuilderCoreWindowOperators =
     new QueryBuilderTDS_WindowRankOperator_DenseRank(),
     new QueryBuilderTDS_WindowRankOperator_Rank(),
     new QueryBuilderTDS_WindowRankOperator_RowNumber(),
+    new QueryBuilderTDS_WindowRankOperator_PercentRank(),
   ];

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,10 @@
 
 import {
   CollectionInstanceValue,
+  type ColSpec,
+  ColSpecArrayInstance,
+  ColSpecInstanceValue,
+  FunctionExpression,
   LambdaFunction,
   LambdaFunctionInstanceValue,
   matchFunctionName,
@@ -29,6 +33,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 +41,7 @@ import { QueryBuilderValueSpecificationProcessor } from '../../../QueryBuilderSt
 import {
   getTDSColumnState,
   getTDSColSortTypeFromFunctionName,
+  getRelationSortColumnFromFunctionName,
 } from '../QueryBuilderTDSHelper.js';
 import { QueryBuilderTDSState } from '../QueryBuilderTDSState.js';
 import {
@@ -45,6 +51,7 @@ import {
   QueryBuilderTDS_WindowAggreationOperatorState,
   QueryBuilderTDS_WindowRankOperatorState,
 } from './QueryBuilderWindowState.js';
+import type { QueryBuilderTDSColumnState } from '../QueryBuilderTDSColumnState.js';
 
 export const processTDS_OLAPGroupByExpression = (
   expression: SimpleFunctionExpression,
@@ -179,13 +186,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 +216,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 +244,198 @@ export const processTDS_OLAPGroupByExpression = (
   tdsState.windowState.addWindowColumn(olapGroupByColumnState);
   tdsState.setShowWindowFuncPanel(true);
 };
+
+const process_WindowOperatorState = (
+  colSpec: ColSpec,
+  tdsState: QueryBuilderTDSState,
+): QueryBuilderTDS_WindowOperatorState => {
+  if (colSpec.function2) {
+    //process function 1
+    const function1Lambda = guaranteeType(
+      guaranteeType(colSpec.function1, LambdaFunctionInstanceValue).values[0],
+      LambdaFunction,
+    );
+    const function1Column = guaranteeType(
+      function1Lambda.expressionSequence[0],
+      FunctionExpression,
+      `Can't process typed window aggregation: expects function1 to be a Function Expression`,
+    );
+    const aggColumnState = getTDSColumnState(
+      tdsState,
+      function1Column.functionName,
+    );
+
+    //process function2
+    const aggLambda = guaranteeType(
+      guaranteeType(colSpec.function2, LambdaFunctionInstanceValue).values[0],
+      LambdaFunction,
+    );
+    const aggFunctionExp = guaranteeType(
+      aggLambda.expressionSequence[0],
+      SimpleFunctionExpression,
+    );
+
+    const operation = guaranteeNonNullable(
+      tdsState.windowState.findOperator(aggFunctionExp.functionName, true),
+      `Operator '${aggFunctionExp.functionName}' not supported yet for typed TDS`,
+    );
+
+    const operatorState = new QueryBuilderTDS_WindowAggreationOperatorState(
+      tdsState.windowState,
+      operation,
+      aggColumnState,
+    );
+
+    //add parameter vlaues
+    const lambdaParameters: string[] = [];
+    function1Lambda.functionType.parameters.forEach((param) => {
+      guaranteeType(param, VariableExpression);
+      lambdaParameters.push(param.name);
+    });
+    const aggLambdaParamName = guaranteeType(
+      aggLambda.functionType.parameters[0],
+      VariableExpression,
+    ).name;
+    lambdaParameters.push(aggLambdaParamName);
+    operatorState.setLambdaParameterNames(lambdaParameters);
+    return operatorState;
+  } else if (colSpec.function1) {
+    //TODO: implement rowNumber as part of rank functions
+    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;
+  } else {
+    throw new UnsupportedOperationError(
+      `Only support aggregation and rank operators in extend() expression`,
+    );
+  }
+};
+
+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`,
+    );
+  }
+};