@finos/legend-query-builder 4.18.16 → 4.18.18

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

@@ -32,6 +32,7 @@ import {
   PropertyExplicitReference,
   Property,
   VariableExpression,
+  FunctionExpression,
 } from '@finos/legend-graph';
 import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../../graph/QueryBuilderMetaModelConst.js';
 import type { QueryBuilderTDSState } from '../QueryBuilderTDSState.js';
@@ -42,6 +43,11 @@ import {
   UnsupportedOperationError,
 } from '@finos/legend-shared';
 import { DEFAULT_LAMBDA_VARIABLE_NAME } from '@finos/legend-data-cube';
+import {
+  QueryBuilderDerivationProjectionColumnState,
+  QueryBuilderRelationColumnProjectionColumnState,
+  QueryBuilderSimpleProjectionColumnState,
+} from '../projection/QueryBuilderProjectionColumnState.js';
 
 export const buildRelationAggregation = (
   precedingExpression: ValueSpecification,
@@ -131,33 +137,84 @@ export const buildRelationAggregation = (
       ),
       `Could not find projected column matching aggregation column '${aggregationColumnState.columnName}'`,
     );
-    const projectedPropertyExpression = guaranteeType(
-      guaranteeType(projectionColSpec.function1, LambdaFunctionInstanceValue)
-        .values[0]?.expressionSequence[0],
-      AbstractPropertyExpression,
-    );
-    const projectedProperty = guaranteeType(
-      projectedPropertyExpression.func.value,
-      Property,
+    // Add column return type to relationType (computed up-front so we can also
+    // reuse it when building the map lambda for relation/derivation columns).
+    const returnType = guaranteeNonNullable(
+      aggregationColumnState.getColumnType(),
+      `Can't create value spec for aggregation column ${aggregationColumnState.columnName}. Missing type.`,
     );
-    // Second, build a new AbstractPropertyExpression for our map function
-    const newPropertyExpression = new AbstractPropertyExpression('');
-    newPropertyExpression.func = PropertyExplicitReference.create(
-      new Property(
+    // Second, build the map lambda. The shape of the lambda depends on the
+    // kind of projection column being aggregated:
+    //  - Simple (class-property) projections: rebuild an AbstractPropertyExpression
+    //    referencing the projected column name.
+    //  - Relation-column projections (source is an Accessor/Relation): build a
+    //    FunctionExpression over a RelationColumn with the projected name.
+    //  - Derivation projections: reuse the lambda already produced by project().
+    let mapLambda: ValueSpecification;
+    const projectionColumnState = aggregationColumnState.projectionColumnState;
+    if (
+      projectionColumnState instanceof QueryBuilderSimpleProjectionColumnState
+    ) {
+      const projectedPropertyExpression = guaranteeType(
+        guaranteeType(projectionColSpec.function1, LambdaFunctionInstanceValue)
+          .values[0]?.expressionSequence[0],
+        AbstractPropertyExpression,
+      );
+      const projectedProperty = guaranteeType(
+        projectedPropertyExpression.func.value,
+        Property,
+      );
+      const newPropertyExpression = new AbstractPropertyExpression('');
+      newPropertyExpression.func = PropertyExplicitReference.create(
+        new Property(
+          projectionColSpec.name,
+          projectedProperty.multiplicity,
+          projectedProperty.genericType,
+          projectedProperty._OWNER,
+        ),
+      );
+      newPropertyExpression.parametersValues = [
+        new VariableExpression(DEFAULT_LAMBDA_VARIABLE_NAME, Multiplicity.ONE),
+      ];
+      mapLambda = buildGenericLambdaFunctionInstanceValue(
+        [DEFAULT_LAMBDA_VARIABLE_NAME],
+        [newPropertyExpression],
+        queryBuilderState.graphManagerState.graph,
+      );
+    } else if (
+      projectionColumnState instanceof
+      QueryBuilderRelationColumnProjectionColumnState
+    ) {
+      const projectedColumn = new RelationColumn(
         projectionColSpec.name,
-        projectedProperty.multiplicity,
-        projectedProperty.genericType,
-        projectedProperty._OWNER,
-      ),
-    );
-    newPropertyExpression.parametersValues = [
-      new VariableExpression(DEFAULT_LAMBDA_VARIABLE_NAME, Multiplicity.ONE),
-    ];
-    const mapLambda = buildGenericLambdaFunctionInstanceValue(
-      [DEFAULT_LAMBDA_VARIABLE_NAME],
-      [newPropertyExpression],
-      queryBuilderState.graphManagerState.graph,
-    );
+        GenericTypeExplicitReference.create(new GenericType(returnType)),
+      );
+      const columnExpression = new FunctionExpression(projectionColSpec.name);
+      columnExpression.func = projectedColumn;
+      columnExpression.parametersValues = [
+        new VariableExpression(DEFAULT_LAMBDA_VARIABLE_NAME, Multiplicity.ONE),
+      ];
+      mapLambda = buildGenericLambdaFunctionInstanceValue(
+        [DEFAULT_LAMBDA_VARIABLE_NAME],
+        [columnExpression],
+        queryBuilderState.graphManagerState.graph,
+      );
+    } else if (
+      projectionColumnState instanceof
+      QueryBuilderDerivationProjectionColumnState
+    ) {
+      // The derivation lambda was already serialized as part of project();
+      // reuse it directly so we don't need to re-serialize it here.
+      mapLambda = guaranteeNonNullable(
+        projectionColSpec.function1,
+        `Could not find projected derivation lambda for aggregation column '${aggregationColumnState.columnName}'`,
+      );
+    } else {
+      throw new UnsupportedOperationError(
+        `Can't build relation groupBy() aggregation map function: unsupported projection column state`,
+        projectionColumnState,
+      );
+    }
     colSpec.function1 = mapLambda;
 
     // Reduce function (function2)
@@ -174,10 +231,6 @@ export const buildRelationAggregation = (
     colSpec.function2 = reduceLambda;
 
     // Add column return type to relationType
-    const returnType = guaranteeNonNullable(
-      aggregationColumnState.getColumnType(),
-      `Can't create value spec for aggregation column ${aggregationColumnState.columnName}. Missing type.`,
-    );
     relationType.columns.push(
       new RelationColumn(
         aggregationColumnState.columnName,

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

@@ -40,6 +40,7 @@ import {
 } from '../../../../../graph/QueryBuilderMetaModelConst.js';
 import type { QueryBuilderTDSColumnState } from '../../QueryBuilderTDSColumnState.js';
 import { getTDSColumnDerivedProperyFromType } from '../../QueryBuilderTDSHelper.js';
+import { QueryBuilderRelationColumnProjectionColumnState } from '../../projection/QueryBuilderProjectionColumnState.js';
 
 export const buildtdsPropertyExpressionFromColState = (
   filterConditionState: PostFilterConditionState,
@@ -64,6 +65,18 @@ export const buildtdsPropertyExpressionFromColState = (
     _funcExp.func = col;
     _funcExp.parametersValues = [variableName];
     return _funcExp;
+  } else if (
+    colState instanceof QueryBuilderRelationColumnProjectionColumnState
+  ) {
+    // Fallback when parent lambda isn't available yet (e.g. when an operator
+    // is asked to build its expression in isolation): the projection state
+    // already carries the `RelationColumn`, so build the column accessor
+    // directly.
+    const col = colState.column;
+    const _funcExp = new FunctionExpression(col.name);
+    _funcExp.func = col;
+    _funcExp.parametersValues = [variableName];
+    return _funcExp;
   } else {
     const tdsPropertyExpression = new AbstractPropertyExpression('');
     let tdsDerivedPropertyName: TDS_COLUMN_GETTER;

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

@@ -17,25 +17,38 @@
 import {
   type Type,
   type ValueSpecification,
-  type FunctionExpression,
+  FunctionExpression,
   type LambdaFunction,
   Enumeration,
   PrimitiveType,
   PrecisePrimitiveType,
+  SimpleFunctionExpression,
+  matchFunctionName,
 } from '@finos/legend-graph';
 import { QueryBuilderPostFilterOperator } from '../QueryBuilderPostFilterOperator.js';
 import { buildPostFilterConditionState } from '../QueryBuilderPostFilterStateBuilder.js';
 import {
-  type PostFilterConditionState,
   type QueryBuilderPostFilterState,
+  PostFilterConditionState,
   PostFilterValueSpecConditionValueState,
 } from '../QueryBuilderPostFilterState.js';
-import { QueryBuilderSimpleProjectionColumnState } from '../../projection/QueryBuilderProjectionColumnState.js';
+import {
+  QueryBuilderRelationColumnProjectionColumnState,
+  QueryBuilderSimpleProjectionColumnState,
+} from '../../projection/QueryBuilderProjectionColumnState.js';
 import { buildPostFilterConditionExpressionHelper } from './QueryBuilderPostFilterOperatorValueSpecificationBuilder.js';
-import { isPropertyExpressionChainOptional } from '../../../../QueryBuilderValueSpecificationHelper.js';
+import { getTDSColumnState } from '../../QueryBuilderTDSHelper.js';
+import {
+  buildNotExpression,
+  isPropertyExpressionChainOptional,
+  unwrapNotExpression,
+} from '../../../../QueryBuilderValueSpecificationHelper.js';
 import { type Hashable, hashArray } from '@finos/legend-shared';
 import { QUERY_BUILDER_STATE_HASH_STRUCTURE } from '../../../../QueryBuilderStateHashUtils.js';
-import { TDS_COLUMN_GETTER } from '../../../../../graph/QueryBuilderMetaModelConst.js';
+import {
+  QUERY_BUILDER_SUPPORTED_FUNCTIONS,
+  TDS_COLUMN_GETTER,
+} from '../../../../../graph/QueryBuilderMetaModelConst.js';
 
 export class QueryBuilderPostFilterOperator_IsEmpty
   extends QueryBuilderPostFilterOperator
@@ -84,6 +97,15 @@ export class QueryBuilderPostFilterOperator_IsEmpty
             .propertyExpression,
         );
       }
+      if (
+        postFilterState.leftConditionValue instanceof
+        QueryBuilderRelationColumnProjectionColumnState
+      ) {
+        return (
+          postFilterState.leftConditionValue.column.multiplicity.lowerBound ===
+          0
+        );
+      }
       return true;
     }
     return false;
@@ -99,10 +121,18 @@ export class QueryBuilderPostFilterOperator_IsEmpty
     postFilterConditionState: PostFilterConditionState,
     parentExpression: LambdaFunction | undefined,
   ): ValueSpecification | undefined {
+    // For relation-column projections there is no `TDSRow.isNull` derived
+    // property to lean on, so wrap the column expression in `isEmpty(...)`
+    // (mirrors how the where-filter `is empty` operator builds its lambda).
+    const operatorFunctionFullPath =
+      postFilterConditionState.leftConditionValue instanceof
+      QueryBuilderRelationColumnProjectionColumnState
+        ? QUERY_BUILDER_SUPPORTED_FUNCTIONS.IS_EMPTY
+        : undefined;
     return buildPostFilterConditionExpressionHelper(
       postFilterConditionState,
       this,
-      undefined,
+      operatorFunctionFullPath,
       parentExpression,
     );
   }
@@ -111,6 +141,24 @@ export class QueryBuilderPostFilterOperator_IsEmpty
     postFilterState: QueryBuilderPostFilterState,
     expression: FunctionExpression,
   ): PostFilterConditionState | undefined {
+    // Round-trip: handle the relation-column variant emitted as
+    // `isEmpty($row.<col>)` (no TDSRow getter available).
+    if (
+      expression instanceof SimpleFunctionExpression &&
+      matchFunctionName(
+        expression.functionName,
+        QUERY_BUILDER_SUPPORTED_FUNCTIONS.IS_EMPTY,
+      ) &&
+      expression.parametersValues.length === 1 &&
+      expression.parametersValues[0] instanceof FunctionExpression
+    ) {
+      const columnFuncExp = expression.parametersValues[0];
+      const columnState = getTDSColumnState(
+        postFilterState.tdsState,
+        columnFuncExp.functionName,
+      );
+      return new PostFilterConditionState(postFilterState, columnState, this);
+    }
     return buildPostFilterConditionState(
       postFilterState,
       expression,
@@ -135,6 +183,43 @@ export class QueryBuilderPostFilterOperator_IsNotEmpty extends QueryBuilderPostF
     return TDS_COLUMN_GETTER.IS_NOT_NULL;
   }
 
+  override buildPostFilterConditionExpression(
+    postFilterConditionState: PostFilterConditionState,
+    parentExpression: LambdaFunction | undefined,
+  ): ValueSpecification | undefined {
+    // For relation-column projections, `is not empty` has no TDS column getter
+    // shortcut either; build it as `not(isEmpty(...))` instead.
+    if (
+      postFilterConditionState.leftConditionValue instanceof
+      QueryBuilderRelationColumnProjectionColumnState
+    ) {
+      const inner = super.buildPostFilterConditionExpression(
+        postFilterConditionState,
+        parentExpression,
+      );
+      return inner ? buildNotExpression(inner) : undefined;
+    }
+    return super.buildPostFilterConditionExpression(
+      postFilterConditionState,
+      parentExpression,
+    );
+  }
+
+  override buildPostFilterConditionState(
+    postFilterState: QueryBuilderPostFilterState,
+    expression: FunctionExpression,
+  ): PostFilterConditionState | undefined {
+    // Round-trip: unwrap a leading `not(...)` (relation-column variant) before
+    // delegating to the IsEmpty builder.
+    if (expression instanceof SimpleFunctionExpression) {
+      const inner = unwrapNotExpression(expression);
+      if (inner) {
+        return super.buildPostFilterConditionState(postFilterState, inner);
+      }
+    }
+    return super.buildPostFilterConditionState(postFilterState, expression);
+  }
+
   override get hashCode(): string {
     return hashArray([
       QUERY_BUILDER_STATE_HASH_STRUCTURE.POST_FILTER_OPERATOR_IS_NOT_EMPTY,

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

@@ -285,7 +285,7 @@ export const appendProjection = (
   // build projection
   if (
     tdsState.aggregationState.columns.length &&
-    !tdsState.queryBuilderState.isFetchStructureTyped
+    !tdsState.queryBuilderState.useRelation
   ) {
     // aggregation
     const groupByFunction = new SimpleFunctionExpression(

package/src/stores/filter/QueryBuilderFilterState.ts

@@ -308,11 +308,21 @@ export class FilterPropertyExpressionSourceState extends FilterConditionSourceSt
 export class FilterRelationColumnSourceState extends FilterConditionSourceState {
   readonly columnName: string;
   readonly columnType: Type;
+  readonly columnMultiplicity: Multiplicity;
 
-  constructor(columnName: string, columnType: Type) {
+  constructor(
+    columnName: string,
+    columnType: Type,
+    columnMultiplicity: Multiplicity,
+  ) {
     super();
     this.columnName = columnName;
     this.columnType = columnType;
+    this.columnMultiplicity = columnMultiplicity;
+  }
+
+  get multiplicity(): Multiplicity {
+    return this.columnMultiplicity;
   }
 
   get type(): Type {
@@ -361,6 +371,8 @@ export class FilterRelationColumnSourceState extends FilterConditionSourceState
     return hashArray([
       QUERY_BUILDER_STATE_HASH_STRUCTURE.FILTER_CONDITION_SOURCE_RELATION_COLUMN,
       this.columnName,
+      this.columnMultiplicity.lowerBound,
+      this.columnMultiplicity.upperBound ?? '',
     ]);
   }
 }

package/src/stores/filter/QueryBuilderFilterStateBuilder.ts

@@ -331,10 +331,31 @@ const processFilterTree = (
           filterConditionState.sourceState instanceof
           FilterRelationColumnSourceState
         ) {
-          const leftSide = expression.parametersValues[0];
+          // For a relation-column source the raw expression can be one of:
+          //   - `isEmpty(col($x))`     (IsEmpty / other unary ops)
+          //   - `not(isEmpty(col($x)))` (IsNotEmpty)
+          //   - `op(col($x), value)`   (binary ops like equal, lessThan, ...)
+          // Walk down through any `not(...)` and any wrapping function call
+          // until we find the relation-column accessor `col($x)`, then read
+          // its variable parameter.
+          let current: ValueSpecification | undefined = expression;
+          while (
+            current instanceof SimpleFunctionExpression &&
+            !(
+              current.parametersValues[0] instanceof FunctionExpression &&
+              current.parametersValues[0].parametersValues[0] instanceof
+                VariableExpression
+            )
+          ) {
+            current = current.parametersValues[0];
+          }
+          const columnAccessor =
+            current instanceof SimpleFunctionExpression
+              ? current.parametersValues[0]
+              : current;
           const varExpr = guaranteeType(
-            leftSide instanceof FunctionExpression
-              ? leftSide.parametersValues[0]
+            columnAccessor instanceof FunctionExpression
+              ? columnAccessor.parametersValues[0]
               : undefined,
             VariableExpression,
             `Can't process filter expression: relation column filter must reference a variable`,

package/src/stores/filter/operators/QueryBuilderFilterOperatorValueSpecificationBuilder.ts

@@ -142,6 +142,7 @@ export const buildFilterConditionState = (
         new FilterRelationColumnSourceState(
           col.name,
           col.genericType.value.rawType,
+          col.multiplicity,
         ),
       );
     } else {

package/src/stores/filter/operators/QueryBuilderFilterOperator_IsEmpty.ts

@@ -18,6 +18,7 @@ import {
   type QueryBuilderFilterState,
   type FilterConditionState,
   FilterPropertyExpressionSourceState,
+  FilterRelationColumnSourceState,
 } from '../QueryBuilderFilterState.js';
 import { QueryBuilderFilterOperator } from '../QueryBuilderFilterOperator.js';
 import {
@@ -52,16 +53,21 @@ export class QueryBuilderFilterOperator_IsEmpty
     filterConditionState: FilterConditionState,
   ): boolean {
     const propertyType = filterConditionState.leftConditionType;
-    // First check if property is optional
-    if (
-      !(
-        filterConditionState.sourceState instanceof
-        FilterPropertyExpressionSourceState
-      ) ||
-      !isPropertyExpressionChainOptional(
-        filterConditionState.propertyExpressionState.propertyExpression,
-      )
-    ) {
+    const sourceState = filterConditionState.sourceState;
+    // First check if source is optional (multiplicity lower bound === 0)
+    if (sourceState instanceof FilterPropertyExpressionSourceState) {
+      if (
+        !isPropertyExpressionChainOptional(
+          filterConditionState.propertyExpressionState.propertyExpression,
+        )
+      ) {
+        return false;
+      }
+    } else if (sourceState instanceof FilterRelationColumnSourceState) {
+      if (sourceState.columnMultiplicity.lowerBound !== 0) {
+        return false;
+      }
+    } else {
       return false;
     }
     return (