@finos/legend-query-builder 4.15.17 → 4.15.19

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

@@ -21,6 +21,7 @@ import {
   matchFunctionName,
   SimpleFunctionExpression,
   VariableExpression,
+  AbstractPropertyExpression,
 } from '@finos/legend-graph';
 import {
   assertTrue,
@@ -41,6 +42,8 @@ import { extractNullableStringFromInstanceValue } from '../../../QueryBuilderVal
 import { FETCH_STRUCTURE_IMPLEMENTATION } from '../../QueryBuilderFetchStructureImplementationState.js';
 import { QueryBuilderTDSState } from '../QueryBuilderTDSState.js';
 
+import { QueryBuilderAggregateOperator_Wavg } from './operators/QueryBuilderAggregateOperator_Wavg.js';
+
 export const processTDSAggregateExpression = (
   expression: SimpleFunctionExpression,
   parentExpression: SimpleFunctionExpression | undefined,
@@ -151,6 +154,16 @@ export const processTDSAggregateExpression = (
           projectionColumnState,
         ),
       );
+      if (
+        projectionColumnState.wavgWeight &&
+        aggregateColumnState &&
+        aggregateColumnState.operator instanceof
+          QueryBuilderAggregateOperator_Wavg
+      ) {
+        aggregateColumnState.operator.setWeight(
+          projectionColumnState.wavgWeight,
+        );
+      }
       if (aggregateColumnState) {
         aggregationState.addColumn(aggregateColumnState);
         if (
@@ -181,6 +194,62 @@ export const processTDSAggregateExpression = (
   }
 };
 
+export const processWAVGRowMapperExpression = (
+  expression: SimpleFunctionExpression,
+  parentExpression: SimpleFunctionExpression | undefined,
+  queryBuilderState: QueryBuilderState,
+  parentLambda: LambdaFunction,
+): void => {
+  // check parent expression is agg
+  assertTrue(
+    Boolean(
+      parentExpression &&
+        matchFunctionName(
+          parentExpression.functionName,
+          QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_AGG,
+        ),
+    ),
+    `Can't process wavgRowMapper() expression: only support wavgRowMapper() used within an agg() expression`,
+  );
+
+  // check number of parameters
+  assertTrue(
+    expression.parametersValues.length === 2,
+    `Can't process wavgRowMapper() expression: wavgRowMapper() expects 2 arguments`,
+  );
+
+  //checking type of parameters
+  const wavgInput = expression.parametersValues;
+  wavgInput.map((p) =>
+    assertType(
+      p,
+      AbstractPropertyExpression,
+      `Can't process wavgRowMapper() expression: wavgRowMapper() expects arguments to be Property Expressions`,
+    ),
+  );
+
+  QueryBuilderValueSpecificationProcessor.processChild(
+    guaranteeNonNullable(expression.parametersValues[0]),
+    expression,
+    parentLambda,
+    queryBuilderState,
+  );
+
+  //setting weight here then build when agg is built
+  if (
+    queryBuilderState.fetchStructureState.implementation instanceof
+    QueryBuilderTDSState
+  ) {
+    const tdsState = queryBuilderState.fetchStructureState.implementation;
+    const projectionColumnState = guaranteeNonNullable(
+      tdsState.projectionColumns[tdsState.projectionColumns.length - 1],
+    );
+    projectionColumnState.setWavgWeight(
+      expression.parametersValues[1] as AbstractPropertyExpression,
+    );
+  }
+};
+
 export const processTDSGroupByExpression = (
   expression: SimpleFunctionExpression,
   queryBuilderState: QueryBuilderState,

package/src/stores/fetch-structure/tds/aggregation/operators/QueryBuilderAggregateOperator_Wavg.ts

@@ -0,0 +1,136 @@
+/**
+ * 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 {
+  PRIMITIVE_TYPE,
+  type ValueSpecification,
+  type SimpleFunctionExpression,
+  type VariableExpression,
+  type PureModel,
+  type AbstractPropertyExpression,
+  matchFunctionName,
+} from '@finos/legend-graph';
+import { QueryBuilderAggregateColumnState } from '../QueryBuilderAggregationState.js';
+import { QueryBuilderAggregateOperator } from '../QueryBuilderAggregateOperator.js';
+import {
+  type QueryBuilderProjectionColumnState,
+  QueryBuilderSimpleProjectionColumnState,
+} from '../../projection/QueryBuilderProjectionColumnState.js';
+import { buildAggregateExpression } from './QueryBuilderAggregateOperatorValueSpecificationBuilder.js';
+import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../../../graph/QueryBuilderMetaModelConst.js';
+import { type Hashable, hashArray, guaranteeType } from '@finos/legend-shared';
+import { QUERY_BUILDER_STATE_HASH_STRUCTURE } from '../../../../QueryBuilderStateHashUtils.js';
+import { action, makeObservable, observable } from 'mobx';
+
+export class QueryBuilderAggregateOperator_Wavg
+  extends QueryBuilderAggregateOperator
+  implements Hashable
+{
+  weight: AbstractPropertyExpression | undefined;
+
+  constructor() {
+    super();
+    makeObservable(this, {
+      weight: observable,
+      setWeight: action,
+    });
+  }
+
+  setWeight(val: AbstractPropertyExpression | undefined) {
+    this.weight = val;
+  }
+
+  getLabel(projectionColumnState?: QueryBuilderProjectionColumnState): string {
+    return 'wavg';
+  }
+
+  getName(projectionColumnState: QueryBuilderProjectionColumnState): string {
+    return projectionColumnState.columnName;
+  }
+
+  isCompatibleWithColumn(
+    projectionColumnState: QueryBuilderProjectionColumnState,
+  ): boolean {
+    if (
+      projectionColumnState instanceof QueryBuilderSimpleProjectionColumnState
+    ) {
+      const propertyType =
+        projectionColumnState.propertyExpressionState.propertyExpression.func
+          .value.genericType.value.rawType;
+      return (
+        [
+          PRIMITIVE_TYPE.NUMBER,
+          PRIMITIVE_TYPE.INTEGER,
+          PRIMITIVE_TYPE.DECIMAL,
+          PRIMITIVE_TYPE.FLOAT,
+        ] as string[]
+      ).includes(propertyType.path);
+    }
+    return false;
+  }
+
+  buildAggregateExpression(
+    propertyExpression: AbstractPropertyExpression | undefined,
+    variableName: string,
+    graph: PureModel,
+  ): ValueSpecification {
+    return buildAggregateExpression(
+      QUERY_BUILDER_SUPPORTED_FUNCTIONS.WAVG,
+      variableName,
+      graph,
+    );
+  }
+
+  buildAggregateColumnState(
+    expression: SimpleFunctionExpression,
+    lambdaParam: VariableExpression,
+    projectionColumnState: QueryBuilderProjectionColumnState,
+  ): QueryBuilderAggregateColumnState | undefined {
+    if (
+      matchFunctionName(
+        expression.functionName,
+        QUERY_BUILDER_SUPPORTED_FUNCTIONS.WAVG,
+      )
+    ) {
+      const aggregateColumnState = new QueryBuilderAggregateColumnState(
+        projectionColumnState.tdsState.aggregationState,
+        projectionColumnState,
+        new QueryBuilderAggregateOperator_Wavg(),
+      );
+
+      const currentOperator = guaranteeType(
+        aggregateColumnState.operator,
+        QueryBuilderAggregateOperator_Wavg,
+      );
+
+      aggregateColumnState.setLambdaParameterName(lambdaParam.name);
+
+      aggregateColumnState.setOperator(currentOperator);
+      return aggregateColumnState;
+    }
+    return undefined;
+  }
+
+  override get getOperator(): QueryBuilderAggregateOperator {
+    return new QueryBuilderAggregateOperator_Wavg();
+  }
+
+  get hashCode(): string {
+    return hashArray([
+      QUERY_BUILDER_STATE_HASH_STRUCTURE.AGGREGATE_OPERATOR_WAVG,
+    ]);
+  }
+}

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

@@ -79,6 +79,7 @@ export abstract class QueryBuilderProjectionColumnState
 {
   tdsState: QueryBuilderTDSState;
   columnName: string;
+  wavgWeight: AbstractPropertyExpression | undefined;
 
   constructor(tdsState: QueryBuilderTDSState, columnName: string) {
     super();
@@ -86,7 +87,9 @@ export abstract class QueryBuilderProjectionColumnState
       uuid: false,
       tdsState: false,
       columnName: observable,
+      wavgWeight: observable,
       setColumnName: action,
+      setWavgWeight: action,
       hashCode: computed,
     });
     this.tdsState = tdsState;
@@ -96,6 +99,10 @@ export abstract class QueryBuilderProjectionColumnState
   setColumnName(val: string): void {
     this.columnName = val;
   }
+
+  setWavgWeight(val: AbstractPropertyExpression): void {
+    this.wavgWeight = val;
+  }
 }
 
 export class QueryBuilderSimpleProjectionColumnState

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

@@ -29,6 +29,7 @@ import {
   V1_GraphTransformerContextBuilder,
   matchFunctionName,
   PrimitiveType,
+  LambdaFunctionInstanceValue,
 } from '@finos/legend-graph';
 import {
   guaranteeNonNullable,
@@ -54,6 +55,7 @@ import { appendOLAPGroupByState } from '../window/QueryBuilderWindowValueSpecifi
 import { appendPostFilter } from '../post-filter/QueryBuilderPostFilterValueSpecificationBuilder.js';
 import { buildTDSSortTypeExpression } from '../QueryBuilderTDSHelper.js';
 import { buildRelationProjection } from './QueryBuilderRelationProjectValueSpecBuidler.js';
+import { QueryBuilderAggregateOperator_Wavg } from '../aggregation/operators/QueryBuilderAggregateOperator_Wavg.js';
 
 const buildSortExpression = (
   sortColumnState: SortColumnState,
@@ -340,6 +342,12 @@ export const appendProjection = (
 
       // column aggregation
       if (aggregateColumnState) {
+        if (
+          aggregateColumnState.operator instanceof
+          QueryBuilderAggregateOperator_Wavg
+        ) {
+          aggregateColumnState.setLambdaParameterName('y');
+        }
         const aggregateFunctionExpression = new SimpleFunctionExpression(
           extractElementNameFromPath(QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_AGG),
         );
@@ -371,6 +379,35 @@ export const appendProjection = (
               .graphManagerState.graph,
           );
         }
+        //TODO support wavg on non SimpleProjectionColumnStates as well
+        if (
+          aggregateColumnState.operator instanceof
+            QueryBuilderAggregateOperator_Wavg &&
+          aggregateColumnState.operator.weight &&
+          aggregateColumnState.projectionColumnState instanceof
+            QueryBuilderSimpleProjectionColumnState &&
+          columnLambda instanceof LambdaFunctionInstanceValue
+        ) {
+          //build row mapper
+          const wavgRowMapper = new SimpleFunctionExpression(
+            QUERY_BUILDER_SUPPORTED_FUNCTIONS.WAVG_ROW_MAPPER,
+          );
+          //add params
+          const quantity =
+            aggregateColumnState.projectionColumnState.propertyExpressionState
+              .propertyExpression;
+          const weight = aggregateColumnState.operator.weight;
+          wavgRowMapper.parametersValues = [quantity, weight];
+          if (
+            aggregateCalendarLambda &&
+            aggregateCalendarLambda instanceof LambdaFunctionInstanceValue
+          ) {
+            aggregateCalendarLambda.values[0]!.expressionSequence[0] =
+              wavgRowMapper;
+          } else if (columnLambda instanceof LambdaFunctionInstanceValue) {
+            columnLambda.values[0]!.expressionSequence[0] = wavgRowMapper;
+          }
+        }
         aggregateFunctionExpression.parametersValues = [
           aggregateCalendarLambda ?? columnLambda,
           aggregateLambda,

package/tsconfig.json

@@ -137,6 +137,7 @@
     "./src/stores/fetch-structure/tds/aggregation/operators/QueryBuilderAggregateOperator_StdDev_Population.ts",
     "./src/stores/fetch-structure/tds/aggregation/operators/QueryBuilderAggregateOperator_StdDev_Sample.ts",
     "./src/stores/fetch-structure/tds/aggregation/operators/QueryBuilderAggregateOperator_Sum.ts",
+    "./src/stores/fetch-structure/tds/aggregation/operators/QueryBuilderAggregateOperator_Wavg.ts",
     "./src/stores/fetch-structure/tds/post-filter/QueryBuilderPostFilterOperator.ts",
     "./src/stores/fetch-structure/tds/post-filter/QueryBuilderPostFilterOperatorLoader.ts",
     "./src/stores/fetch-structure/tds/post-filter/QueryBuilderPostFilterState.ts",
@@ -244,6 +245,7 @@
     "./src/components/explorer/QueryBuilderFunctionsExplorerPanel.tsx",
     "./src/components/explorer/QueryBuilderMilestoningParameterEditor.tsx",
     "./src/components/explorer/QueryBuilderPropertySearchPanel.tsx",
+    "./src/components/fetch-structure/QueryBuilderAggParam.tsx",
     "./src/components/fetch-structure/QueryBuilderFetchStructurePanel.tsx",
     "./src/components/fetch-structure/QueryBuilderGraphFetchTreePanel.tsx",
     "./src/components/fetch-structure/QueryBuilderPostFilterPanel.tsx",