@finos/legend-application-query 5.0.1 → 5.2.1

package/src/stores/QueryBuilderPreviewDataHelper.ts

@@ -14,27 +14,12 @@
  * limitations under the License.
  */
 
-import {
-  type AbstractPropertyExpression,
-  type Class,
-  type PureModel,
-  GenericType,
-  GenericTypeExplicitReference,
-  PrimitiveInstanceValue,
-  PRIMITIVE_TYPE,
-  CollectionInstanceValue,
-  CORE_PURE_PATH,
-  extractElementNameFromPath,
-  FunctionType,
-  LambdaFunction,
-  Multiplicity,
-  SimpleFunctionExpression,
-  TYPICAL_MULTIPLICITY_TYPE,
+import type {
+  RawLambda,
+  AbstractPropertyExpression,
 } from '@finos/legend-graph';
-import {
-  DEFAULT_LAMBDA_VARIABLE_NAME,
-  QUERY_BUILDER_SUPPORTED_FUNCTIONS,
-} from '../QueryBuilder_Const.js';
+import { guaranteeNonNullable } from '@finos/legend-shared';
+import type { QueryBuilderAggregateOperator } from './QueryBuilderAggregationState.js';
 import { QueryBuilderAggregateOperator_Average } from './aggregateOperators/QueryBuilderAggregateOperator_Average.js';
 import { QueryBuilderAggregateOperator_Count } from './aggregateOperators/QueryBuilderAggregateOperator_Count.js';
 import { QueryBuilderAggregateOperator_DistinctCount } from './aggregateOperators/QueryBuilderAggregateOperator_DistinctCount.js';
@@ -43,109 +28,82 @@ import { QueryBuilderAggregateOperator_Min } from './aggregateOperators/QueryBui
 import { QueryBuilderAggregateOperator_StdDev_Population } from './aggregateOperators/QueryBuilderAggregateOperator_StdDev_Population.js';
 import { QueryBuilderAggregateOperator_StdDev_Sample } from './aggregateOperators/QueryBuilderAggregateOperator_StdDev_Sample.js';
 import { QueryBuilderAggregateOperator_Sum } from './aggregateOperators/QueryBuilderAggregateOperator_Sum.js';
-import type { QueryBuilderAggregateOperator } from './QueryBuilderAggregationState.js';
-import { buildGetAllFunction } from './QueryBuilderLambdaBuilder.js';
-import { buildGenericLambdaFunctionInstanceValue } from './QueryBuilderValueSpecificationBuilderHelper.js';
+import { QueryBuilderSimpleProjectionColumnState } from './QueryBuilderProjectionState.js';
+import type { QueryBuilderState } from './QueryBuilderState.js';
+import {
+  COLUMN_SORT_TYPE,
+  SortColumnState,
+} from './QueryResultSetModifierState.js';
 
-const buildGroupByFunction = (
-  getAllFunction: SimpleFunctionExpression,
-  propertyExpression: AbstractPropertyExpression,
-  aggregates: [QueryBuilderAggregateOperator, string][],
-  includePropertyValue: boolean,
-  graph: PureModel,
-): SimpleFunctionExpression => {
-  const multiplicityOne = graph.getTypicalMultiplicity(
-    TYPICAL_MULTIPLICITY_TYPE.ONE,
-  );
-  const typeAny = graph.getType(CORE_PURE_PATH.ANY);
-  const typeString = graph.getPrimitiveType(PRIMITIVE_TYPE.STRING);
-  const lambdaFunction = new LambdaFunction(
-    new FunctionType(typeAny, multiplicityOne),
-  );
+const PREVIEW_DATA_TAKE_LIMIT = 10;
+const PREVIEW_DATA_NON_NUMERIC_VALUE_COLUMN_NAME = 'Value';
+const PREVIEW_DATA_NON_NUMERIC_COUNT_COLUMN_NAME = 'Count';
 
-  const groupByFunction = new SimpleFunctionExpression(
-    extractElementNameFromPath(QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_GROUP_BY),
-    multiplicityOne,
-  );
+enum NUMERIC_AGG_FUNC {
+  COUNT = 'Count',
+  DISTINCT_COUNT = 'Distinct Count',
+  SUM = 'Sum',
+  MIN = 'Min',
+  MAX = 'Max',
+  AVERAGE = 'Average',
+  STD_DEV_POPULATION = 'Std Dev (Population)',
+  STD_DEV_SAMPLE = 'Std Dev (Sample)',
+}
 
-  const colLambdas = new CollectionInstanceValue(
-    graph.getTypicalMultiplicity(
-      includePropertyValue
-        ? TYPICAL_MULTIPLICITY_TYPE.ONE
-        : TYPICAL_MULTIPLICITY_TYPE.ZERO,
-    ),
-  );
-  const aggregateLambdas = new CollectionInstanceValue(
-    new Multiplicity(aggregates.length, aggregates.length),
-  );
-  const noOfCols = aggregates.length + (includePropertyValue ? 1 : 0);
-  const colAliases = new CollectionInstanceValue(
-    new Multiplicity(noOfCols, noOfCols),
-  );
+const NUMERIC_AGG_FUNC_TO_AGG_OP: [
+  NUMERIC_AGG_FUNC,
+  typeof QueryBuilderAggregateOperator,
+][] = [
+  [NUMERIC_AGG_FUNC.COUNT, QueryBuilderAggregateOperator_Count],
+  [
+    NUMERIC_AGG_FUNC.DISTINCT_COUNT,
+    QueryBuilderAggregateOperator_DistinctCount,
+  ],
+  [NUMERIC_AGG_FUNC.SUM, QueryBuilderAggregateOperator_Sum],
+  [NUMERIC_AGG_FUNC.MIN, QueryBuilderAggregateOperator_Min],
+  [NUMERIC_AGG_FUNC.MAX, QueryBuilderAggregateOperator_Max],
+  [NUMERIC_AGG_FUNC.AVERAGE, QueryBuilderAggregateOperator_Average],
+  [
+    NUMERIC_AGG_FUNC.STD_DEV_POPULATION,
+    QueryBuilderAggregateOperator_StdDev_Population,
+  ],
+  [
+    NUMERIC_AGG_FUNC.STD_DEV_SAMPLE,
+    QueryBuilderAggregateOperator_StdDev_Sample,
+  ],
+];
 
-  if (includePropertyValue) {
-    colLambdas.values.push(
-      buildGenericLambdaFunctionInstanceValue(
-        DEFAULT_LAMBDA_VARIABLE_NAME,
-        [propertyExpression],
-        graph,
-      ),
-    );
-    const valueColAlias = new PrimitiveInstanceValue(
-      GenericTypeExplicitReference.create(new GenericType(typeString)),
-      multiplicityOne,
-    );
-    valueColAlias.values.push('Value');
-    colAliases.values.push(valueColAlias);
-  }
+const createProjectionColumn = (
+  queryBuilderState: QueryBuilderState,
+  propertyExpression: AbstractPropertyExpression,
+  columnName: string,
+): QueryBuilderSimpleProjectionColumnState => {
+  const col = new QueryBuilderSimpleProjectionColumnState(
+    queryBuilderState.fetchStructureState.projectionState,
+    propertyExpression,
+    false,
+  );
+  col.setColumnName(columnName);
+  return col;
+};
 
-  aggregates.forEach((pair) => {
-    const aggregateFunctionExpression = new SimpleFunctionExpression(
-      extractElementNameFromPath(QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_AGG),
-      multiplicityOne,
-    );
-    aggregateFunctionExpression.parametersValues = [
-      buildGenericLambdaFunctionInstanceValue(
-        DEFAULT_LAMBDA_VARIABLE_NAME,
-        [propertyExpression],
-        graph,
-      ),
-      buildGenericLambdaFunctionInstanceValue(
-        DEFAULT_LAMBDA_VARIABLE_NAME,
-        [
-          pair[0].buildAggregateExpression(
-            propertyExpression,
-            DEFAULT_LAMBDA_VARIABLE_NAME,
-            graph,
-          ),
-        ],
-        graph,
-      ),
-    ];
-    aggregateLambdas.values.push(aggregateFunctionExpression);
+const createQueryBuilderState = (
+  queryBuilderState: QueryBuilderState,
+): QueryBuilderState => {
+  const builderState = queryBuilderState.createBareBuilderState();
+  builderState.querySetupState = queryBuilderState.querySetupState;
+  return builderState;
+};
 
-    const colAlias = new PrimitiveInstanceValue(
-      GenericTypeExplicitReference.create(new GenericType(typeString)),
-      multiplicityOne,
-    );
-    colAlias.values.push(pair[1]);
-    colAliases.values.push(colAlias);
-  });
-  groupByFunction.parametersValues = [
-    getAllFunction,
-    colLambdas,
-    aggregateLambdas,
-    colAliases,
-  ];
-  lambdaFunction.expressionSequence[0] = groupByFunction;
-  return groupByFunction;
+export type QueryBuilderPreviewData = {
+  columns: string[];
+  rows: { values: (string | number)[] }[];
 };
 
 export const buildNumericPreviewDataQuery = (
+  queryBuilderState: QueryBuilderState,
   propertyExpression: AbstractPropertyExpression,
-  _class: Class,
-  graph: PureModel,
-): LambdaFunction => {
+): RawLambda => {
   // Build the following query
   //
   // ClassX.all()->groupBy(
@@ -171,44 +129,29 @@ export const buildNumericPreviewDataQuery = (
   //     'Std Dev (Sample)'
   //   ]
   // )
-  const multiplicityOne = graph.getTypicalMultiplicity(
-    TYPICAL_MULTIPLICITY_TYPE.ONE,
-  );
-  const typeAny = graph.getType(CORE_PURE_PATH.ANY);
-  const lambdaFunction = new LambdaFunction(
-    new FunctionType(typeAny, multiplicityOne),
-  );
-  const groupByFunction = buildGroupByFunction(
-    buildGetAllFunction(_class, multiplicityOne),
-    propertyExpression,
-    [
-      [new QueryBuilderAggregateOperator_Count(), 'Count'],
-      [new QueryBuilderAggregateOperator_DistinctCount(), 'Distinct Count'],
-      [new QueryBuilderAggregateOperator_Sum(), 'Sum'],
-      [new QueryBuilderAggregateOperator_Min(), 'Min'],
-      [new QueryBuilderAggregateOperator_Max(), 'Max'],
-      [new QueryBuilderAggregateOperator_Average(), 'Average'],
-      [
-        new QueryBuilderAggregateOperator_StdDev_Population(),
-        'Standard Deviation (Population)',
-      ],
-      [
-        new QueryBuilderAggregateOperator_StdDev_Sample(),
-        'Standard Deviation (Sample)',
-      ],
-    ] as [QueryBuilderAggregateOperator, string][],
-    false,
-    graph,
-  );
-  lambdaFunction.expressionSequence[0] = groupByFunction;
-  return lambdaFunction;
+  const builderState = createQueryBuilderState(queryBuilderState);
+  const projectionState = builderState.fetchStructureState.projectionState;
+  const aggregationState = projectionState.aggregationState;
+  NUMERIC_AGG_FUNC_TO_AGG_OP.forEach((val) => {
+    const colState = createProjectionColumn(
+      builderState,
+      propertyExpression,
+      val[0],
+    );
+    projectionState.columns.push(colState);
+    const valAggOp = guaranteeNonNullable(
+      aggregationState.operators.find((t) => t instanceof val[1]),
+    );
+    aggregationState.changeColumnAggregateOperator(valAggOp, colState);
+  });
+
+  return builderState.resultState.buildExecutionRawLambda();
 };
 
 export const buildNonNumericPreviewDataQuery = (
+  queryBuilderState: QueryBuilderState,
   propertyExpression: AbstractPropertyExpression,
-  _class: Class,
-  graph: PureModel,
-): LambdaFunction => {
+): RawLambda => {
   // Build the following query
   //
   // ClassX.all()->groupBy(
@@ -216,85 +159,47 @@ export const buildNonNumericPreviewDataQuery = (
   //     x|$x.prop
   //   ],
   //   [
-  //     agg(x|$x.prop, x|$x->distinct()->count())
+  //     agg(x|$x.prop, x|$x->count())
   //   ],
   //   [
   //     'Value',
   //     'Count'
   //   ]
-  // )->take(10)->sort([desc('Count'), asc('Value')])
-  const multiplicityOne = graph.getTypicalMultiplicity(
-    TYPICAL_MULTIPLICITY_TYPE.ONE,
-  );
-  const typeAny = graph.getType(CORE_PURE_PATH.ANY);
-  const lambdaFunction = new LambdaFunction(
-    new FunctionType(typeAny, multiplicityOne),
-  );
-
-  // build groupBy()
-  const groupByFunction = buildGroupByFunction(
-    buildGetAllFunction(_class, multiplicityOne),
+  // )->sort([desc('Count'), asc('Value')])->take(10)
+  const builderState = createQueryBuilderState(queryBuilderState);
+  const valueProjectionColState = createProjectionColumn(
+    builderState,
     propertyExpression,
-    [[new QueryBuilderAggregateOperator_Count(), 'Count']] as [
-      QueryBuilderAggregateOperator,
-      string,
-    ][],
-    true,
-    graph,
+    PREVIEW_DATA_NON_NUMERIC_VALUE_COLUMN_NAME,
   );
-  lambdaFunction.expressionSequence[0] = groupByFunction;
-
-  // build sort()
-  const sortFunction = new SimpleFunctionExpression(
-    extractElementNameFromPath(QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_SORT),
-    multiplicityOne,
-  );
-  const sortColumnFunctions = new CollectionInstanceValue(
-    new Multiplicity(2, 2),
-    undefined,
+  const valueCountProjectionState = createProjectionColumn(
+    builderState,
+    propertyExpression,
+    PREVIEW_DATA_NON_NUMERIC_COUNT_COLUMN_NAME,
   );
-  sortColumnFunctions.values = [
-    [QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_DESC, 'Count'],
-    [QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_ASC, 'Value'],
-  ].map((pair) => {
-    const sortColumnFunction = new SimpleFunctionExpression(
-      extractElementNameFromPath(pair[0] as string),
-      multiplicityOne,
-    );
-    const sortColumnName = new PrimitiveInstanceValue(
-      GenericTypeExplicitReference.create(
-        new GenericType(graph.getPrimitiveType(PRIMITIVE_TYPE.STRING)),
-      ),
-      multiplicityOne,
-    );
-    sortColumnName.values = [pair[1]];
-    sortColumnFunction.parametersValues[0] = sortColumnName;
-    return sortColumnFunction;
-  });
-  sortFunction.parametersValues[0] = groupByFunction;
-  sortFunction.parametersValues[1] = sortColumnFunctions;
-
-  // build take()
-  const limit = new PrimitiveInstanceValue(
-    GenericTypeExplicitReference.create(
-      new GenericType(graph.getPrimitiveType(PRIMITIVE_TYPE.INTEGER)),
+  builderState.fetchStructureState.projectionState.columns = [
+    valueProjectionColState,
+    valueCountProjectionState,
+  ];
+  const distinctCountOp = guaranteeNonNullable(
+    builderState.fetchStructureState.projectionState.aggregationState.operators.find(
+      (t) => t instanceof QueryBuilderAggregateOperator_Count,
     ),
-    multiplicityOne,
   );
-  limit.values = [10];
-  const takeFunction = new SimpleFunctionExpression(
-    extractElementNameFromPath(QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_TAKE),
-    multiplicityOne,
+  builderState.fetchStructureState.projectionState.aggregationState.changeColumnAggregateOperator(
+    distinctCountOp,
+    valueCountProjectionState,
   );
-  takeFunction.parametersValues[0] = sortFunction;
-  takeFunction.parametersValues[1] = limit;
-
-  lambdaFunction.expressionSequence[0] = takeFunction;
-
-  return lambdaFunction;
-};
-
-export type QueryBuilderPreviewData = {
-  columns: string[];
-  rows: { values: (string | number)[] }[];
+  // result set
+  builderState.resultSetModifierState.limit = PREVIEW_DATA_TAKE_LIMIT;
+  const sortValueCount = new SortColumnState(
+    builderState,
+    valueCountProjectionState,
+  );
+  sortValueCount.sortType = COLUMN_SORT_TYPE.DESC;
+  builderState.resultSetModifierState.sortColumns = [
+    sortValueCount,
+    new SortColumnState(builderState, valueProjectionColState),
+  ];
+  return builderState.resultState.buildExecutionRawLambda();
 };

package/src/stores/QueryBuilderProjectionState.ts

@@ -68,34 +68,24 @@ import {
   RawLambda,
   stub_RawLambda,
   isStubbed_RawLambda,
-  buildRawLambdaFromLambdaFunction,
 } from '@finos/legend-graph';
 import {
   DEFAULT_LAMBDA_VARIABLE_NAME,
   QUERY_BUILDER_SOURCE_ID_LABEL,
 } from '../QueryBuilder_Const.js';
-import { QueryBuilderAggregationState } from './QueryBuilderAggregationState.js';
-import { QueryBuilderAggregateOperator_Count } from './aggregateOperators/QueryBuilderAggregateOperator_Count.js';
-import { QueryBuilderAggregateOperator_Distinct } from './aggregateOperators/QueryBuilderAggregateOperator_Distinct.js';
-import { QueryBuilderAggregateOperator_Sum } from './aggregateOperators/QueryBuilderAggregateOperator_Sum.js';
-import { QueryBuilderAggregateOperator_Average } from './aggregateOperators/QueryBuilderAggregateOperator_Average.js';
-import { QueryBuilderAggregateOperator_StdDev_Population } from './aggregateOperators/QueryBuilderAggregateOperator_StdDev_Population.js';
-import { QueryBuilderAggregateOperator_StdDev_Sample } from './aggregateOperators/QueryBuilderAggregateOperator_StdDev_Sample.js';
-import { QueryBuilderAggregateOperator_DistinctCount } from './aggregateOperators/QueryBuilderAggregateOperator_DistinctCount.js';
-import { QueryBuilderAggregateOperator_Min } from './aggregateOperators/QueryBuilderAggregateOperator_Min.js';
-import { QueryBuilderAggregateOperator_Max } from './aggregateOperators/QueryBuilderAggregateOperator_Max.js';
-import { QueryBuilderAggregateOperator_JoinString } from './aggregateOperators/QueryBuilderAggregateOperator_JoinString.js';
+import {
+  type QueryBuilderAggregateOperator,
+  QueryBuilderAggregationState,
+} from './QueryBuilderAggregationState.js';
+import { buildGenericLambdaFunctionInstanceValue } from './QueryBuilderValueSpecificationBuilderHelper.js';
+import { LambdaEditorState } from '@finos/legend-application';
 import {
   type QueryBuilderPreviewData,
-  buildNonNumericPreviewDataQuery,
   buildNumericPreviewDataQuery,
+  buildNonNumericPreviewDataQuery,
 } from './QueryBuilderPreviewDataHelper.js';
-import { buildGenericLambdaFunctionInstanceValue } from './QueryBuilderValueSpecificationBuilderHelper.js';
-import { LambdaEditorState } from '@finos/legend-application';
 
-export enum QUERY_BUILDER_PROJECTION_DND_TYPE {
-  PROJECTION_COLUMN = 'PROJECTION_COLUMN',
-}
+export const QUERY_BUILDER_PROJECTION_COLUMN_DND_TYPE = 'PROJECTION_COLUMN';
 
 export interface QueryBuilderProjectionColumnDragSource {
   columnState: QueryBuilderProjectionColumnState;
@@ -104,7 +94,6 @@ export interface QueryBuilderProjectionColumnDragSource {
 export abstract class QueryBuilderProjectionColumnState {
   readonly uuid = uuid();
   projectionState: QueryBuilderProjectionState;
-  isBeingDragged = false;
   columnName: string;
 
   constructor(
@@ -114,9 +103,7 @@ export abstract class QueryBuilderProjectionColumnState {
     makeObservable(this, {
       uuid: false,
       projectionState: false,
-      isBeingDragged: observable,
       columnName: observable,
-      setIsBeingDragged: action,
       setColumnName: action,
     });
 
@@ -124,10 +111,6 @@ export abstract class QueryBuilderProjectionColumnState {
     this.columnName = columnName;
   }
 
-  setIsBeingDragged(val: boolean): void {
-    this.isBeingDragged = val;
-  }
-
   setColumnName(val: string): void {
     this.columnName = val;
   }
@@ -380,7 +363,10 @@ export class QueryBuilderProjectionState {
   aggregationState: QueryBuilderAggregationState;
   isConvertDerivationProjectionObjects = false;
 
-  constructor(queryBuilderState: QueryBuilderState) {
+  constructor(
+    queryBuilderState: QueryBuilderState,
+    operators: QueryBuilderAggregateOperator[],
+  ) {
     makeAutoObservable(this, {
       queryBuilderState: false,
       removeColumn: action,
@@ -390,18 +376,7 @@ export class QueryBuilderProjectionState {
     });
 
     this.queryBuilderState = queryBuilderState;
-    this.aggregationState = new QueryBuilderAggregationState(this, [
-      new QueryBuilderAggregateOperator_Count(),
-      new QueryBuilderAggregateOperator_DistinctCount(),
-      new QueryBuilderAggregateOperator_Distinct(),
-      new QueryBuilderAggregateOperator_Sum(),
-      new QueryBuilderAggregateOperator_Average(),
-      new QueryBuilderAggregateOperator_Min(),
-      new QueryBuilderAggregateOperator_Max(),
-      new QueryBuilderAggregateOperator_StdDev_Population(),
-      new QueryBuilderAggregateOperator_StdDev_Sample(),
-      new QueryBuilderAggregateOperator_JoinString(),
-    ]);
+    this.aggregationState = new QueryBuilderAggregationState(this, operators);
   }
 
   *convertDerivationProjectionObjects(): GeneratorFn<void> {
@@ -606,7 +581,9 @@ export class QueryBuilderProjectionState {
   addNewBlankDerivation(): void {
     const derivation = new QueryBuilderDerivationProjectionColumnState(
       this,
-      this.queryBuilderState.graphManagerState.graphManager.HACKY__createDefaultBlankLambda(),
+      this.queryBuilderState.graphManagerState.graphManager.createDefaultBasicRawLambda(
+        { addDummyParameter: true },
+      ),
     );
     this.addColumn(derivation);
     derivation.derivationLambdaEditorState.setLambdaString(
@@ -709,13 +686,9 @@ export class QueryBuilderProjectionState {
         case PRIMITIVE_TYPE.FLOAT: {
           const previewResult =
             (yield this.queryBuilderState.graphManagerState.graphManager.executeMapping(
-              buildRawLambdaFromLambdaFunction(
-                buildNumericPreviewDataQuery(
-                  propertyExpression,
-                  this.queryBuilderState.querySetupState._class,
-                  this.queryBuilderState.graphManagerState.graph,
-                ),
-                this.queryBuilderState.graphManagerState,
+              buildNumericPreviewDataQuery(
+                this.queryBuilderState,
+                propertyExpression,
               ),
               this.queryBuilderState.querySetupState.mapping,
               runtime,
@@ -752,13 +725,9 @@ export class QueryBuilderProjectionState {
         case PRIMITIVE_TYPE.DATETIME: {
           const previewResult =
             (yield this.queryBuilderState.graphManagerState.graphManager.executeMapping(
-              buildRawLambdaFromLambdaFunction(
-                buildNonNumericPreviewDataQuery(
-                  propertyExpression,
-                  this.queryBuilderState.querySetupState._class,
-                  this.queryBuilderState.graphManagerState.graph,
-                ),
-                this.queryBuilderState.graphManagerState,
+              buildNonNumericPreviewDataQuery(
+                this.queryBuilderState,
+                propertyExpression,
               ),
               this.queryBuilderState.querySetupState.mapping,
               runtime,
@@ -793,4 +762,22 @@ export class QueryBuilderProjectionState {
       );
     }
   }
+
+  get validationIssues(): string[] | undefined {
+    if (this.queryBuilderState.fetchStructureState.isProjectionMode()) {
+      const hasDuplicatedProjectionColumns = this.columns.some(
+        (column) =>
+          this.columns.filter((c) => c.columnName === column.columnName)
+            .length > 1,
+      );
+      if (hasDuplicatedProjectionColumns) {
+        return ['Query has duplicated projection columns'];
+      }
+      const hasNoProjectionColumns = this.columns.length === 0;
+      if (hasNoProjectionColumns) {
+        return ['Query has no projection columns'];
+      }
+    }
+    return undefined;
+  }
 }

package/src/stores/QueryBuilderPropertySearchPanelState.ts

@@ -262,7 +262,7 @@ export class QueryBuilderPropertySearchPanelState {
                 ),
               );
               if (
-                propertyTreeNodeData.mappingData.mapped &&
+                propertyTreeNodeData?.mappingData.mapped &&
                 !propertyTreeNodeData.isPartOfDerivedPropertyBranch
               ) {
                 nextLevelPropertyNodes.push(propertyTreeNodeData);

package/src/stores/QueryBuilderResultState.ts

@@ -48,16 +48,18 @@ export class QueryBuilderResultState {
   queryBuilderState: QueryBuilderState;
   exportDataState = ActionState.create();
   previewLimit = DEFAULT_LIMIT;
-  isExecutingQuery = false;
+  isRunningQuery = false;
   isGeneratingPlan = false;
   executionResult?: ExecutionResult | undefined;
   executionPlanState: ExecutionPlanState;
   executionDuration?: number | undefined;
+  queryRunPromise: Promise<ExecutionResult> | undefined = undefined;
 
   constructor(queryBuilderState: QueryBuilderState) {
     makeAutoObservable(this, {
       queryBuilderState: false,
       executionPlanState: false,
+      setIsRunningQuery: action,
       setExecutionResult: action,
     });
 
@@ -68,16 +70,28 @@ export class QueryBuilderResultState {
     );
   }
 
+  setIsRunningQuery = (val: boolean): void => {
+    this.isRunningQuery = val;
+  };
+
   setExecutionResult = (val: ExecutionResult | undefined): void => {
     this.executionResult = val;
   };
+
   setExecutionDuration = (val: number | undefined): void => {
     this.executionDuration = val;
   };
+
   setPreviewLimit = (val: number): void => {
     this.previewLimit = Math.max(1, val);
   };
 
+  setQueryRunPromise = (
+    promise: Promise<ExecutionResult> | undefined,
+  ): void => {
+    this.queryRunPromise = promise;
+  };
+
   buildExecutionRawLambda(): RawLambda {
     let query: RawLambda;
     if (this.queryBuilderState.isQuerySupported()) {
@@ -172,9 +186,9 @@ export class QueryBuilderResultState {
     }
   }
 
-  *execute(): GeneratorFn<void> {
+  *runQuery(): GeneratorFn<void> {
     try {
-      this.isExecutingQuery = true;
+      this.isRunningQuery = true;
       const mapping = guaranteeNonNullable(
         this.queryBuilderState.querySetupState.mapping,
         'Mapping is required to execute query',
@@ -185,15 +199,19 @@ export class QueryBuilderResultState {
       );
       const query = this.buildExecutionRawLambda();
       const startTime = Date.now();
-      const result =
-        (yield this.queryBuilderState.graphManagerState.graphManager.executeMapping(
+      const promise =
+        this.queryBuilderState.graphManagerState.graphManager.executeMapping(
           query,
           mapping,
           runtime,
           this.queryBuilderState.graphManagerState.graph,
-        )) as ExecutionResult;
-      this.setExecutionResult(result);
-      this.setExecutionDuration(Date.now() - startTime);
+        );
+      this.setQueryRunPromise(promise);
+      const result = (yield promise) as ExecutionResult;
+      if (this.queryRunPromise === promise) {
+        this.setExecutionResult(result);
+        this.setExecutionDuration(Date.now() - startTime);
+      }
     } catch (error) {
       assertErrorThrown(error);
       this.queryBuilderState.applicationStore.log.error(
@@ -202,7 +220,7 @@ export class QueryBuilderResultState {
       );
       this.queryBuilderState.applicationStore.notifyError(error);
     } finally {
-      this.isExecutingQuery = false;
+      this.setIsRunningQuery(false);
     }
   }
 

package/src/stores/QueryBuilderSetupState.ts

@@ -106,7 +106,7 @@ export class QueryBuilderSetupState {
   get classes(): Class[] {
     return this.queryBuilderState.graphManagerState.graph.ownClasses
       .concat(
-        this.queryBuilderState.graphManagerState.filterSystemElementOptions(
+        this.queryBuilderState.graphManagerState.collectExposedSystemElements(
           this.queryBuilderState.graphManagerState.graph.systemModel.ownClasses,
         ),
       )