@finos/legend-query-builder 4.18.17 → 4.18.18

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/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 (