@finos/legend-query-builder 4.9.4 → 4.10.1

package/src/stores/QueryBuilderResultState.ts

@@ -17,14 +17,15 @@
 import { action, flow, makeObservable, observable } from 'mobx';
 import {
   type GeneratorFn,
+  type ContentType,
   assertErrorThrown,
   LogEvent,
   guaranteeNonNullable,
-  type ContentType,
   downloadFileUsingDataURI,
   ActionState,
   StopWatch,
   getContentTypeFileExtension,
+  isBoolean,
 } from '@finos/legend-shared';
 import type { QueryBuilderState } from './QueryBuilderState.js';
 import {
@@ -37,6 +38,7 @@ import {
   buildRawLambdaFromLambdaFunction,
   reportGraphAnalytics,
   extractExecutionResultValues,
+  TDSExecutionResult,
 } from '@finos/legend-graph';
 import { buildLambdaFunction } from './QueryBuilderValueSpecificationBuilder.js';
 import { DEFAULT_TAB_SIZE } from '@finos/legend-application';
@@ -81,6 +83,7 @@ export class QueryBuilderResultState {
   latestRunHashCode?: string | undefined;
   queryRunPromise: Promise<ExecutionResult> | undefined = undefined;
   isQueryUsageViewerOpened = false;
+  rowData: Record<string, string | number | boolean | null>[] = [];
 
   selectedCells: QueryBuilderTDSResultCellData[];
   mousedOverCell: QueryBuilderTDSResultCellData | null = null;
@@ -110,6 +113,8 @@ export class QueryBuilderResultState {
       setQueryRunPromise: action,
       setIsQueryUsageViewerOpened: action,
       exportData: flow,
+      getRowData: action,
+      setRowData: action,
       runQuery: flow,
       cancelQuery: flow,
       generatePlan: flow,
@@ -124,6 +129,36 @@ export class QueryBuilderResultState {
     );
   }
 
+  getRowData(): Record<string, string | number | boolean | null>[] {
+    if (
+      this.executionResult &&
+      this.executionResult instanceof TDSExecutionResult
+    ) {
+      const data = this.executionResult.result.rows.map((_row, rowIdx) => {
+        const row: Record<string, string | number | boolean | null> = {};
+        const cols = (this.executionResult as TDSExecutionResult).result
+          .columns;
+        _row.values.forEach((value, colIdx) => {
+          // `ag-grid` shows `false` value as empty string so we have
+          // call `.toString()` to avoid this behavior.
+          // See https://github.com/finos/legend-studio/issues/1008
+          row[cols[colIdx] as string] = isBoolean(value)
+            ? String(value)
+            : value;
+        });
+        row.rowNumber = rowIdx;
+        return row;
+      });
+      this.rowData = data;
+      return data;
+    }
+    return [];
+  }
+
+  setRowData(val: Record<string, string | number | boolean | null>[]): void {
+    this.rowData = val;
+  }
+
   setIsSelectingCells(val: boolean): void {
     this.isSelectingCells = val;
   }

package/src/stores/QueryBuilderStateHashUtils.ts

@@ -45,6 +45,8 @@ export enum QUERY_BUILDER_STATE_HASH_STRUCTURE {
   POST_FILTER_TREE_CONDIITION_NODE_DATA = 'POST_FILTER_TREE_CONDITION_NODE_DATA',
   POST_FILTER_TREE_BLANK_CONDITION_NODE_DATA = 'POST_FILTER_TREE_BLANK_CONDITION_NODE_DATA',
   POST_FILTER_CONDITION_STATE = 'POST_FILTER_CONDITION_STATE',
+  POST_FILTER_CONDITION_RIGHT_VALUE = 'POST_FILTER_CONDITION_RIGHT_VALUE',
+  POST_FILTER_CONDITION_RIGHT_VALUE_SPEC = 'POST_FILTER_CONDITION_RIGHT_VALUE_SPEC',
   POST_FILTER_OPERATOR_CONTAIN = 'POST_FILTER_OPERATOR_CONTAIN',
   POST_FILTER_OPERATOR_NOT_CONTAIN = 'POST_FILTER_OPERATOR_NOT_CONTAIN',
   POST_FILTER_OPERATOR_END_WITH = 'POST_FILTER_OPERATOR_END_WITH',

package/src/stores/QueryBuilderValueSpecificationBuilder.ts

@@ -14,14 +14,9 @@
  * limitations under the License.
  */
 
-import {
-  UnsupportedOperationError,
-  guaranteeNonNullable,
-  guaranteeType,
-} from '@finos/legend-shared';
+import { guaranteeNonNullable, guaranteeType } from '@finos/legend-shared';
 import {
   type Class,
-  type ValueSpecification,
   Multiplicity,
   getMilestoneTemporalStereotype,
   extractElementNameFromPath,
@@ -33,11 +28,8 @@ import {
   GenericTypeExplicitReference,
   LambdaFunction,
   SimpleFunctionExpression,
-  PrimitiveInstanceValue,
-  PrimitiveType,
   SUPPORTED_FUNCTIONS,
   RuntimePointer,
-  INTERNAL__UnknownValueSpecification,
 } from '@finos/legend-graph';
 import type { QueryBuilderState } from './QueryBuilderState.js';
 import { buildFilterExpression } from './filter/QueryBuilderFilterValueSpecificationBuilder.js';
@@ -46,11 +38,6 @@ import type { QueryBuilderFetchStructureState } from './fetch-structure/QueryBui
 import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../graph/QueryBuilderMetaModelConst.js';
 import { buildWatermarkExpression } from './watermark/QueryBuilderWatermarkValueSpecificationBuilder.js';
 import { buildExecutionQueryFromLambdaFunction } from './shared/LambdaParameterState.js';
-import {
-  QueryBuilderSimpleConstantExpressionState,
-  type QueryBuilderConstantExpressionState,
-  QueryBuilderCalculatedConstantExpressionState,
-} from './QueryBuilderConstantsState.js';
 import {
   QueryBuilderEmbeddedFromExecutionContextState,
   type QueryBuilderExecutionContextState,
@@ -90,40 +77,6 @@ const buildGetAllVersionsFunction = (
   return _func;
 };
 
-const buildLetExpression = (
-  constantExpressionState: QueryBuilderConstantExpressionState,
-): SimpleFunctionExpression => {
-  const varName = constantExpressionState.variable.name;
-  const leftSide = new PrimitiveInstanceValue(
-    GenericTypeExplicitReference.create(new GenericType(PrimitiveType.STRING)),
-  );
-  leftSide.values = [varName];
-  const letFunc = new SimpleFunctionExpression(
-    extractElementNameFromPath(SUPPORTED_FUNCTIONS.LET),
-  );
-  let value: ValueSpecification;
-  if (
-    constantExpressionState instanceof QueryBuilderSimpleConstantExpressionState
-  ) {
-    value = constantExpressionState.value;
-  } else if (
-    constantExpressionState instanceof
-    QueryBuilderCalculatedConstantExpressionState
-  ) {
-    value = new INTERNAL__UnknownValueSpecification(
-      constantExpressionState.value,
-    );
-  } else {
-    throw new UnsupportedOperationError(
-      `Can't build let() expression: unsupported constant state`,
-      constantExpressionState,
-    );
-  }
-
-  letFunc.parametersValues = [leftSide, value];
-  return letFunc;
-};
-
 const buildExecutionContextState = (
   executionState: QueryBuilderExecutionContextState,
   lambdaFunction: LambdaFunction,
@@ -237,8 +190,9 @@ export const buildLambdaFunction = (
 
   // build variable expressions
   if (queryBuilderState.constantState.constants.length) {
-    const letExpressions =
-      queryBuilderState.constantState.constants.map(buildLetExpression);
+    const letExpressions = queryBuilderState.constantState.constants.map((e) =>
+      e.buildLetExpression(),
+    );
     lambdaFunction.expressionSequence = [
       ...letExpressions,
       ...lambdaFunction.expressionSequence,

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

@@ -48,7 +48,7 @@ export abstract class QueryBuilderPostFilterOperator implements Hashable {
   isCompatibleWithPostFilterColumn(
     postFilterState: PostFilterConditionState,
   ): boolean {
-    const columnType = postFilterState.columnState.getColumnType();
+    const columnType = postFilterState.leftConditionValue.getColumnType();
     if (columnType) {
       return this.isCompatibleWithType(columnType);
     }

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

@@ -21,10 +21,12 @@ import {
   type ValueSpecification,
   type ExecutionResult,
   type VariableExpression,
+  type SimpleFunctionExpression,
   Enumeration,
   PRIMITIVE_TYPE,
   observe_ValueSpecification,
   PrimitiveType,
+  CollectionInstanceValue,
 } from '@finos/legend-graph';
 import {
   type GeneratorFn,
@@ -70,7 +72,12 @@ import { QUERY_BUILDER_GROUP_OPERATION } from '../../../QueryBuilderGroupOperati
 import type { QueryBuilderTDSState } from '../QueryBuilderTDSState.js';
 import { QUERY_BUILDER_STATE_HASH_STRUCTURE } from '../../../QueryBuilderStateHashUtils.js';
 import type { QueryBuilderTDSColumnState } from '../QueryBuilderTDSColumnState.js';
-import { isValueExpressionReferencedInValue } from '../../../QueryBuilderValueSpecificationHelper.js';
+import {
+  getCollectionValueSpecificationType,
+  getNonCollectionValueSpecificationType,
+  isValueExpressionReferencedInValue,
+} from '../../../QueryBuilderValueSpecificationHelper.js';
+import { buildtdsPropertyExpressionFromColState } from './operators/QueryBuilderPostFilterOperatorValueSpecificationBuilder.js';
 
 export enum QUERY_BUILDER_POST_FILTER_DND_TYPE {
   GROUP_CONDITION = 'GROUP_CONDITION',
@@ -207,8 +214,8 @@ export class QueryBuilderPostFilterTreeGroupNodeData
     super(parentId);
     makeObservable(this, {
       groupOperation: observable,
-      childrenIds: observable,
       setGroupOperation: action,
+      childrenIds: observable,
       addChildNode: action,
       removeChildNode: action,
       dragPreviewLabel: computed,
@@ -307,10 +314,130 @@ export class QueryBuilderPostFilterTreeBlankConditionNodeData
   }
 }
 
+export abstract class PostFilterConditionValueState implements Hashable {
+  conditionState: PostFilterConditionState;
+
+  constructor(conditionState: PostFilterConditionState) {
+    this.conditionState = conditionState;
+  }
+
+  get type(): Type | undefined {
+    return undefined;
+  }
+
+  get isCollection(): boolean {
+    return false;
+  }
+
+  get hashCode(): string {
+    return hashArray([
+      QUERY_BUILDER_STATE_HASH_STRUCTURE.POST_FILTER_CONDITION_RIGHT_VALUE,
+    ]);
+  }
+
+  abstract appendConditionValue(expressionVal: SimpleFunctionExpression): void;
+}
+
+export class PostFilterValueSpecConditionValueState extends PostFilterConditionValueState {
+  value?: ValueSpecification | undefined;
+
+  constructor(
+    conditionState: PostFilterConditionState,
+    value?: ValueSpecification | undefined,
+  ) {
+    super(conditionState);
+    makeObservable(this, {
+      value: observable,
+      setValue: action,
+    });
+    this.value = this.setValue(value);
+  }
+
+  override get type(): Type | undefined {
+    if (this.value instanceof CollectionInstanceValue) {
+      return getCollectionValueSpecificationType(
+        this.conditionState.postFilterState.tdsState.queryBuilderState
+          .graphManagerState.graph,
+        this.value.values,
+      );
+    }
+    return this.value
+      ? getNonCollectionValueSpecificationType(this.value)
+      : undefined;
+  }
+
+  setValue(
+    val: ValueSpecification | undefined,
+  ): ValueSpecification | undefined {
+    this.value = val
+      ? observe_ValueSpecification(
+          val,
+          this.conditionState.postFilterState.tdsState.queryBuilderState
+            .observerContext,
+        )
+      : undefined;
+    return this.value;
+  }
+  override appendConditionValue(expressionVal: SimpleFunctionExpression): void {
+    if (this.value) {
+      expressionVal.parametersValues.push(this.value);
+    }
+  }
+
+  override get isCollection(): boolean {
+    return this.value instanceof CollectionInstanceValue;
+  }
+
+  override get hashCode(): string {
+    return hashArray([
+      QUERY_BUILDER_STATE_HASH_STRUCTURE.POST_FILTER_CONDITION_RIGHT_VALUE_SPEC,
+      this.value,
+    ]);
+  }
+}
+
+export class PostFilterTDSColumnValueConditionValueState extends PostFilterConditionValueState {
+  tdsColumn: QueryBuilderTDSColumnState;
+
+  constructor(
+    conditionState: PostFilterConditionState,
+    tdsColumn: QueryBuilderTDSColumnState,
+  ) {
+    super(conditionState);
+    makeObservable(this, {
+      tdsColumn: observable,
+      changeCol: action,
+    });
+    this.tdsColumn = tdsColumn;
+  }
+
+  override get type(): Type | undefined {
+    return this.tdsColumn.getColumnType();
+  }
+
+  override get isCollection(): boolean {
+    return false;
+  }
+  override appendConditionValue(expressionVal: SimpleFunctionExpression): void {
+    const tdsPropertyExpression = buildtdsPropertyExpressionFromColState(
+      this.conditionState,
+      this.tdsColumn,
+      this.conditionState.postFilterState.tdsState.queryBuilderState
+        .graphManagerState.graph,
+      undefined,
+    );
+    expressionVal.parametersValues.push(tdsPropertyExpression);
+  }
+
+  changeCol(col: QueryBuilderTDSColumnState): void {
+    this.tdsColumn = col;
+  }
+}
+
 export class PostFilterConditionState implements Hashable {
   readonly postFilterState: QueryBuilderPostFilterState;
-  columnState: QueryBuilderTDSColumnState;
-  value?: ValueSpecification | undefined;
+  leftConditionValue: QueryBuilderTDSColumnState;
+  rightConditionValue: PostFilterConditionValueState;
   operator: QueryBuilderPostFilterOperator;
   typeaheadSearchResults: string[] | undefined;
   typeaheadSearchState = ActionState.create();
@@ -318,18 +445,18 @@ export class PostFilterConditionState implements Hashable {
   constructor(
     postFilterState: QueryBuilderPostFilterState,
     colState: QueryBuilderTDSColumnState,
-    value: ValueSpecification | undefined,
     operator: QueryBuilderPostFilterOperator | undefined,
   ) {
     makeObservable(this, {
       postFilterState: observable,
-      value: observable,
+      rightConditionValue: observable,
       operator: observable,
-      columnState: observable,
+      leftConditionValue: observable,
       typeaheadSearchResults: observable,
       changeOperator: action,
       setColumnState: action,
-      setValue: action,
+      setRightConditionVal: action,
+      buildFromValueSpec: action,
       setOperator: action,
       changeColumn: flow,
       handleTypeaheadSearch: flow,
@@ -338,21 +465,24 @@ export class PostFilterConditionState implements Hashable {
     });
 
     this.postFilterState = postFilterState;
-    this.columnState = colState;
-    this.setValue(value);
+    this.leftConditionValue = colState;
+    this.rightConditionValue = new PostFilterValueSpecConditionValueState(
+      this,
+      undefined,
+    );
     if (operator) {
       this.operator = operator;
     } else {
       assertTrue(
         this.operators.length !== 0,
-        `Can't find an operator for column '${this.columnState.columnName}`,
+        `Can't find an operator for column '${this.leftConditionValue.columnName}`,
       );
       this.operator = guaranteeNonNullable(this.operators[0]);
     }
   }
 
   get columnName(): string {
-    return this.columnState.columnName;
+    return this.leftConditionValue.columnName;
   }
 
   get operators(): QueryBuilderPostFilterOperator[] {
@@ -361,23 +491,43 @@ export class PostFilterConditionState implements Hashable {
     );
   }
 
+  setRightConditionVal(val: PostFilterConditionValueState): void {
+    this.rightConditionValue = val;
+  }
+
+  buildFromValueSpec(val: ValueSpecification | undefined): void {
+    if (
+      this.rightConditionValue instanceof PostFilterValueSpecConditionValueState
+    ) {
+      this.rightConditionValue.setValue(val);
+      return;
+    } else {
+      this.setRightConditionVal(
+        new PostFilterValueSpecConditionValueState(this, val),
+      );
+    }
+  }
   *handleTypeaheadSearch(): GeneratorFn<void> {
     try {
       this.typeaheadSearchState.inProgress();
       this.typeaheadSearchResults = undefined;
       const _columnState =
-        this.columnState instanceof QueryBuilderProjectionColumnState ||
-        this.columnState instanceof QueryBuilderAggregateColumnState
-          ? this.columnState
+        this.leftConditionValue instanceof QueryBuilderProjectionColumnState ||
+        this.leftConditionValue instanceof QueryBuilderAggregateColumnState
+          ? this.leftConditionValue
           : undefined;
       const columnState = guaranteeNonNullable(_columnState);
-      if (performTypeahead(this.value)) {
+      const rightConditionValue = guaranteeType(
+        this.rightConditionValue,
+        PostFilterValueSpecConditionValueState,
+      );
+      if (performTypeahead(rightConditionValue.value)) {
         const result =
           (yield this.postFilterState.tdsState.queryBuilderState.graphManagerState.graphManager.runQuery(
             buildProjectionColumnTypeaheadQuery(
               this.postFilterState.tdsState.queryBuilderState,
               columnState,
-              this.value,
+              rightConditionValue.value,
             ),
             guaranteeNonNullable(
               this.postFilterState.tdsState.queryBuilderState
@@ -404,23 +554,15 @@ export class PostFilterConditionState implements Hashable {
   changeOperator(val: QueryBuilderPostFilterOperator): void {
     this.setOperator(val);
     if (!this.operator.isCompatibleWithConditionValue(this)) {
-      this.setValue(this.operator.getDefaultFilterConditionValue(this));
+      this.buildFromValueSpec(
+        this.operator.getDefaultFilterConditionValue(this),
+      );
     }
   }
-
-  setValue(val: ValueSpecification | undefined): void {
-    this.value = val
-      ? observe_ValueSpecification(
-          val,
-          this.postFilterState.tdsState.queryBuilderState.observerContext,
-        )
-      : undefined;
-  }
-
   setColumnState(
     val: QueryBuilderProjectionColumnState | QueryBuilderAggregateColumnState,
   ): void {
-    this.columnState = val;
+    this.leftConditionValue = val;
   }
 
   setOperator(val: QueryBuilderPostFilterOperator): void {
@@ -450,7 +592,9 @@ export class PostFilterConditionState implements Hashable {
 
       // value
       if (!this.operator.isCompatibleWithConditionValue(this)) {
-        this.setValue(this.operator.getDefaultFilterConditionValue(this));
+        this.buildFromValueSpec(
+          this.operator.getDefaultFilterConditionValue(this),
+        );
       }
     } catch (error) {
       assertErrorThrown(error);
@@ -463,8 +607,8 @@ export class PostFilterConditionState implements Hashable {
   get hashCode(): string {
     return hashArray([
       QUERY_BUILDER_STATE_HASH_STRUCTURE.POST_FILTER_CONDITION_STATE,
-      this.columnState,
-      this.value ?? '',
+      this.leftConditionValue,
+      this.rightConditionValue,
       this.operator,
     ]);
   }
@@ -555,7 +699,7 @@ export class QueryBuilderPostFilterState
     return uniq(
       Array.from(this.nodes.values())
         .filter(filterByType(QueryBuilderPostFilterTreeConditionNodeData))
-        .map((n) => n.condition.columnState),
+        .map((n) => n.condition.leftConditionValue),
     );
   }
 
@@ -883,7 +1027,9 @@ export class QueryBuilderPostFilterState
     return Boolean(
       Array.from(this.nodes.values())
         .filter(filterByType(QueryBuilderPostFilterTreeConditionNodeData))
-        .map((node) => node.condition.value)
+        .map((node) => node.condition.rightConditionValue)
+        .filter(filterByType(PostFilterValueSpecConditionValueState))
+        .map((condition) => condition.value)
         .filter(isNonNullable)
         .find((value) => isValueExpressionReferencedInValue(variable, value)),
     );

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

@@ -23,6 +23,7 @@ import {
   VariableExpression,
   FunctionExpression,
   type SimpleFunctionExpression,
+  type ValueSpecification,
 } from '@finos/legend-graph';
 import {
   assertTrue,
@@ -30,6 +31,7 @@ import {
   guaranteeIsString,
   guaranteeNonNullable,
   guaranteeType,
+  returnUndefOnError,
   UnsupportedOperationError,
 } from '@finos/legend-shared';
 import { QueryBuilderDerivationProjectionColumnState } from '../projection/QueryBuilderProjectionColumnState.js';
@@ -44,6 +46,8 @@ import {
   QueryBuilderPostFilterTreeGroupNodeData,
   TDS_COLUMN_GETTER,
   getTypeFromDerivedProperty,
+  PostFilterValueSpecConditionValueState,
+  PostFilterTDSColumnValueConditionValueState,
 } from './QueryBuilderPostFilterState.js';
 import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../../graph/QueryBuilderMetaModelConst.js';
 import type { QueryBuilderState } from '../../../QueryBuilderState.js';
@@ -102,6 +106,36 @@ const findProjectionColumnState = (
   return columnState;
 };
 
+const buildPostFilterConditionValueState = (
+  rightVal: ValueSpecification | undefined,
+  conditionState: PostFilterConditionState,
+): void => {
+  if (rightVal instanceof AbstractPropertyExpression) {
+    const rightCol = returnUndefOnError(() =>
+      findProjectionColumnState(rightVal, conditionState.postFilterState),
+    );
+    if (rightCol) {
+      conditionState.setRightConditionVal(
+        new PostFilterTDSColumnValueConditionValueState(
+          conditionState,
+          rightCol,
+        ),
+      );
+      return;
+    }
+  }
+  const val = rightVal
+    ? simplifyValueExpression(
+        rightVal,
+        conditionState.postFilterState.tdsState.queryBuilderState
+          .observerContext,
+      )
+    : undefined;
+  conditionState.setRightConditionVal(
+    new PostFilterValueSpecConditionValueState(conditionState, val),
+  );
+};
+
 export const buildPostFilterConditionState = (
   postFilterState: QueryBuilderPostFilterState,
   expression: FunctionExpression,
@@ -119,7 +153,6 @@ export const buildPostFilterConditionState = (
     postConditionState = new PostFilterConditionState(
       postFilterState,
       columnState,
-      undefined,
       operator,
     );
     return postConditionState;
@@ -150,21 +183,17 @@ export const buildPostFilterConditionState = (
     );
 
     // get operation value specification
-    const value = expression.parametersValues[1];
+    const rightSide = expression.parametersValues[1];
 
     // create state
     postConditionState = new PostFilterConditionState(
       postFilterState,
       columnState,
-      value
-        ? simplifyValueExpression(
-            value,
-            postFilterState.tdsState.queryBuilderState.observerContext,
-          )
-        : undefined,
       operator,
     );
 
+    buildPostFilterConditionValueState(rightSide, postConditionState);
+
     //post checks
     assertTrue(
       operator.isCompatibleWithPostFilterColumn(postConditionState),
@@ -174,7 +203,7 @@ export const buildPostFilterConditionState = (
     );
     assertTrue(
       operator.isCompatibleWithConditionValue(postConditionState),
-      `Operator '${operator.getLabel()}' not compatible with value specification ${value?.toString()}`,
+      `Operator '${operator.getLabel()}' not compatible with value specification ${rightSide?.toString()}`,
     );
   }
   return postConditionState;