@finos/legend-query-builder 1.0.2 → 1.0.4

package/src/graphManager/protocol/pure/v1/V1_QueryValueSpecificationBuilderHelper.ts

@@ -201,8 +201,8 @@ export const V1_buildGetAllFunctionExpression = (
   openVariables: string[],
   compileContext: V1_GraphBuilderContext,
   processingContext: V1_ProcessingContext,
-): [SimpleFunctionExpression, ValueSpecification[]] => {
-  const [expression, processedParams] = V1_buildGenericFunctionExpression(
+): SimpleFunctionExpression => {
+  const expression = V1_buildGenericFunctionExpression(
     functionName,
     parameters,
     openVariables,
@@ -218,7 +218,8 @@ export const V1_buildGetAllFunctionExpression = (
   );
   expression.genericType = precedingExpression.genericType;
   expression.multiplicity = precedingExpression.multiplicity;
-  return [expression, processedParams];
+
+  return expression;
 };
 
 export const V1_buildExistsFunctionExpression = (
@@ -227,7 +228,7 @@ export const V1_buildExistsFunctionExpression = (
   openVariables: string[],
   compileContext: V1_GraphBuilderContext,
   processingContext: V1_ProcessingContext,
-): [SimpleFunctionExpression, ValueSpecification[]] => {
+): SimpleFunctionExpression => {
   assertTrue(
     parameters.length === 2,
     `Can't build exists() expression: exists() expects 1 argument`,
@@ -262,22 +263,21 @@ export const V1_buildExistsFunctionExpression = (
       }
     });
   }
-  const processedParameters = [
-    precedingExpression,
-    (parameters[1] as V1_ValueSpecification).accept_ValueSpecificationVisitor(
-      new V1_ValueSpecificationBuilder(
-        compileContext,
-        processingContext,
-        openVariables,
+
+  return V1_buildBaseSimpleFunctionExpression(
+    [
+      precedingExpression,
+      (parameters[1] as V1_ValueSpecification).accept_ValueSpecificationVisitor(
+        new V1_ValueSpecificationBuilder(
+          compileContext,
+          processingContext,
+          openVariables,
+        ),
       ),
-    ),
-  ];
-  const expression = V1_buildBaseSimpleFunctionExpression(
-    processedParameters,
+    ],
     functionName,
     compileContext,
   );
-  return [expression, processedParameters];
 };
 
 export const V1_buildFilterFunctionExpression = (
@@ -286,7 +286,7 @@ export const V1_buildFilterFunctionExpression = (
   openVariables: string[],
   compileContext: V1_GraphBuilderContext,
   processingContext: V1_ProcessingContext,
-): [SimpleFunctionExpression, ValueSpecification[]] => {
+): SimpleFunctionExpression => {
   assertTrue(
     parameters.length === 2,
     `Can't build filter() expression: filter() expects 1 argument`,
@@ -318,19 +318,18 @@ export const V1_buildFilterFunctionExpression = (
       });
     }
   }
-  const processedParams = [
-    precedingExpression,
-    (parameters[1] as V1_ValueSpecification).accept_ValueSpecificationVisitor(
-      new V1_ValueSpecificationBuilder(
-        compileContext,
-        processingContext,
-        openVariables,
-      ),
-    ),
-  ];
 
   const expression = V1_buildBaseSimpleFunctionExpression(
-    processedParams,
+    [
+      precedingExpression,
+      (parameters[1] as V1_ValueSpecification).accept_ValueSpecificationVisitor(
+        new V1_ValueSpecificationBuilder(
+          compileContext,
+          processingContext,
+          openVariables,
+        ),
+      ),
+    ],
     functionName,
     compileContext,
   );
@@ -338,7 +337,8 @@ export const V1_buildFilterFunctionExpression = (
   // return type of filter() is the same as that of the function precedes it
   expression.genericType = precedingExpression.genericType;
   expression.multiplicity = precedingExpression.multiplicity;
-  return [expression, processedParams];
+
+  return expression;
 };
 
 export const V1_buildProjectFunctionExpression = (
@@ -347,7 +347,7 @@ export const V1_buildProjectFunctionExpression = (
   openVariables: string[],
   compileContext: V1_GraphBuilderContext,
   processingContext: V1_ProcessingContext,
-): [SimpleFunctionExpression, ValueSpecification[]] => {
+): SimpleFunctionExpression => {
   assertTrue(
     parameters.length === 3,
     `Can't build project() expression: project() expects 2 arguments`,
@@ -417,26 +417,26 @@ export const V1_buildProjectFunctionExpression = (
     }
   });
 
-  const processedParams = [
-    precedingExperession,
-    processedColumnExpressions,
-    (parameters[2] as V1_ValueSpecification).accept_ValueSpecificationVisitor(
-      new V1_ValueSpecificationBuilder(
-        compileContext,
-        processingContext,
-        openVariables,
-      ),
-    ),
-  ];
   const expression = V1_buildBaseSimpleFunctionExpression(
-    processedParams,
+    [
+      precedingExperession,
+      processedColumnExpressions,
+      (parameters[2] as V1_ValueSpecification).accept_ValueSpecificationVisitor(
+        new V1_ValueSpecificationBuilder(
+          compileContext,
+          processingContext,
+          openVariables,
+        ),
+      ),
+    ],
     functionName,
     compileContext,
   );
   expression.genericType = GenericTypeExplicitReference.create(
     new GenericType(compileContext.resolveType(CORE_PURE_PATH.TDS_ROW).value),
   );
-  return [expression, processedParams];
+
+  return expression;
 };
 
 export const V1_buildGroupByFunctionExpression = (
@@ -445,7 +445,7 @@ export const V1_buildGroupByFunctionExpression = (
   openVariables: string[],
   compileContext: V1_GraphBuilderContext,
   processingContext: V1_ProcessingContext,
-): [SimpleFunctionExpression, ValueSpecification[]] => {
+): SimpleFunctionExpression => {
   let topLevelLambdaParameters: V1_Variable[] = [];
   assertTrue(
     parameters.length === 4,
@@ -557,27 +557,27 @@ export const V1_buildGroupByFunctionExpression = (
       ),
   );
 
-  const processedParams = [
-    precedingExperession,
-    processedColumnExpressions,
-    processedAggregationExpressions,
-    (parameters[3] as V1_ValueSpecification).accept_ValueSpecificationVisitor(
-      new V1_ValueSpecificationBuilder(
-        compileContext,
-        processingContext,
-        openVariables,
-      ),
-    ),
-  ];
   const expression = V1_buildBaseSimpleFunctionExpression(
-    processedParams,
+    [
+      precedingExperession,
+      processedColumnExpressions,
+      processedAggregationExpressions,
+      (parameters[3] as V1_ValueSpecification).accept_ValueSpecificationVisitor(
+        new V1_ValueSpecificationBuilder(
+          compileContext,
+          processingContext,
+          openVariables,
+        ),
+      ),
+    ],
     functionName,
     compileContext,
   );
   expression.genericType = GenericTypeExplicitReference.create(
     new GenericType(compileContext.resolveType(CORE_PURE_PATH.TDS_ROW).value),
   );
-  return [expression, processedParams];
+
+  return expression;
 };
 
 export const V1_buildWatermarkFunctionExpression = (
@@ -586,7 +586,7 @@ export const V1_buildWatermarkFunctionExpression = (
   openVariables: string[],
   compileContext: V1_GraphBuilderContext,
   processingContext: V1_ProcessingContext,
-): [SimpleFunctionExpression, ValueSpecification[]] | undefined => {
+): SimpleFunctionExpression | undefined => {
   assertTrue(
     parameters.length === 2,
     `Can't build forWatermark() expression: forWatermark() expects 1 argument`,
@@ -622,8 +622,7 @@ export const V1_buildWatermarkFunctionExpression = (
     });
   }
 
-  const processedParams = [
-    precedingExpression,
+  const watermarkValueParam = guaranteeNonNullable(
     (parameters[1] as V1_ValueSpecification).accept_ValueSpecificationVisitor(
       new V1_ValueSpecificationBuilder(
         compileContext,
@@ -631,9 +630,7 @@ export const V1_buildWatermarkFunctionExpression = (
         openVariables,
       ),
     ),
-  ];
-
-  const watermarkValueParam = guaranteeNonNullable(processedParams[1]);
+  );
   const watermarkValueParamType =
     watermarkValueParam.genericType?.value.rawType;
   assertTrue(
@@ -642,14 +639,15 @@ export const V1_buildWatermarkFunctionExpression = (
   );
 
   const expression = V1_buildBaseSimpleFunctionExpression(
-    processedParams,
+    [precedingExpression, watermarkValueParam],
     functionName,
     compileContext,
   );
 
   expression.genericType = precedingExpression.genericType;
   expression.multiplicity = precedingExpression.multiplicity;
-  return [expression, processedParams];
+
+  return expression;
 };
 
 export const V1_buildOLAPGroupByFunctionExpression = (
@@ -658,7 +656,7 @@ export const V1_buildOLAPGroupByFunctionExpression = (
   openVariables: string[],
   compileContext: V1_GraphBuilderContext,
   processingContext: V1_ProcessingContext,
-): [SimpleFunctionExpression, ValueSpecification[]] | undefined => {
+): SimpleFunctionExpression | undefined => {
   const processedParams: ValueSpecification[] = [];
   assertTrue(
     parameters.length === 5 || parameters.length === 4,
@@ -778,7 +776,8 @@ export const V1_buildOLAPGroupByFunctionExpression = (
   expression.genericType = GenericTypeExplicitReference.create(
     new GenericType(compileContext.resolveType(CORE_PURE_PATH.TDS_ROW).value),
   );
-  return [expression, processedParams];
+
+  return expression;
 };
 
 export const V1_buildSubTypePropertyExpressionTypeInference = (

package/src/stores/QueryBuilderChangeDetectionState.ts

@@ -91,17 +91,19 @@ export class QueryBuilderDiffViewState {
 }
 
 export class QueryBuilderChangeDetectionState {
-  querybuilderState: QueryBuilderState;
-  initState = ActionState.create();
+  readonly querybuilderState: QueryBuilderState;
+
+  readonly initState = ActionState.create();
+
+  querySnapshot?: RawLambda | undefined;
+  hashCodeSnapshot?: string | undefined;
   diffViewState?: QueryBuilderDiffViewState | undefined;
-  initialQuery?: RawLambda | undefined;
-  initialHashCode?: string | undefined;
 
   constructor(queryBuilderState: QueryBuilderState) {
     makeObservable(this, {
       diffViewState: observable,
-      initialHashCode: observable,
-      initialQuery: observable,
+      querySnapshot: observable,
+      hashCodeSnapshot: observable,
       hasChanged: computed,
       initialize: action,
       showDiffViewPanel: action,
@@ -113,12 +115,12 @@ export class QueryBuilderChangeDetectionState {
 
   showDiffViewPanel(): void {
     assertNonNullable(
-      this.initialQuery,
+      this.querySnapshot,
       `Can't show changes: change detection is not properly initialized`,
     );
     this.diffViewState = new QueryBuilderDiffViewState(
       this,
-      this.initialQuery,
+      this.querySnapshot,
       this.querybuilderState.buildQuery(),
     );
   }
@@ -131,13 +133,13 @@ export class QueryBuilderChangeDetectionState {
     if (!this.initState.hasCompleted) {
       return false;
     }
-    return this.querybuilderState.hashCode !== this.initialHashCode;
+    return this.querybuilderState.hashCode !== this.hashCodeSnapshot;
   }
 
   initialize(initialQuery: RawLambda): void {
     this.initState.inProgress();
-    this.initialHashCode = this.querybuilderState.hashCode;
-    this.initialQuery = initialQuery;
+    this.hashCodeSnapshot = this.querybuilderState.hashCode;
+    this.querySnapshot = initialQuery;
     this.initState.complete();
   }
 

package/src/stores/QueryBuilderConstantsState.ts

@@ -57,11 +57,11 @@ export class QueryBuilderConstantExpressionState implements Hashable {
     this.queryBuilderState = queryBuilderState;
     this.value = observe_ValueSpecification(
       value,
-      this.queryBuilderState.observableContext,
+      this.queryBuilderState.observerContext,
     );
     observe_ValueSpecification(
       variable,
-      this.queryBuilderState.observableContext,
+      this.queryBuilderState.observerContext,
     );
     this.variable = variable;
   }
@@ -73,6 +73,7 @@ export class QueryBuilderConstantExpressionState implements Hashable {
         const valSpec = buildDefaultInstanceValue(
           this.queryBuilderState.graphManagerState.graph,
           type,
+          this.queryBuilderState.observerContext,
         );
         this.setValueSpec(valSpec);
       } catch (error) {
@@ -92,7 +93,7 @@ export class QueryBuilderConstantExpressionState implements Hashable {
     }
     this.value = observe_ValueSpecification(
       value,
-      this.queryBuilderState.observableContext,
+      this.queryBuilderState.observerContext,
     );
     const valueSpecType = value.genericType?.value.rawType;
     if (

package/src/stores/QueryBuilderPropertyEditorState.ts

@@ -21,8 +21,6 @@ import {
   guaranteeType,
   type Hashable,
   hashArray,
-  isCamelCase,
-  prettyCamelCase,
   prettyCONSTName,
 } from '@finos/legend-shared';
 import {
@@ -48,6 +46,7 @@ import {
   GenericType,
   PropertyExplicitReference,
   PrimitiveType,
+  type ObserverContext,
 } from '@finos/legend-graph';
 import {
   createNullishValue,
@@ -63,15 +62,12 @@ import {
 } from './shared/ValueSpecificationModifierHelper.js';
 import { generateMilestonedPropertyParameterValue } from './milestoning/QueryBuilderMilestoningHelper.js';
 
-export const prettyPropertyName = (value: string): string =>
-  isCamelCase(value) ? prettyCamelCase(value) : prettyCONSTName(value);
-
 export const getPropertyChainName = (
   propertyExpression: AbstractPropertyExpression,
   humanizePropertyName: boolean,
 ): string => {
   const propertyNameDecorator = humanizePropertyName
-    ? prettyPropertyName
+    ? prettyCONSTName
     : (val: string): string => val;
   const chunks = [propertyNameDecorator(propertyExpression.func.value.name)];
   let currentExpression: ValueSpecification | undefined = propertyExpression;
@@ -146,6 +142,7 @@ export const getPropertyPath = (
 export const generateValueSpecificationForParameter = (
   parameter: VariableExpression,
   graph: PureModel,
+  observerContext: ObserverContext,
 ): ValueSpecification => {
   if (parameter.genericType) {
     const type = parameter.genericType.value.rawType;
@@ -161,9 +158,11 @@ export const generateValueSpecificationForParameter = (
         ),
       );
       if (type !== PrimitiveType.LATESTDATE) {
-        instanceValue_setValues(primitiveInstanceValue, [
-          generateDefaultValueForPrimitiveType(type.name as PRIMITIVE_TYPE),
-        ]);
+        instanceValue_setValues(
+          primitiveInstanceValue,
+          [generateDefaultValueForPrimitiveType(type.name as PRIMITIVE_TYPE)],
+          observerContext,
+        );
       }
       return primitiveInstanceValue;
     } else if (type instanceof Enumeration) {
@@ -174,7 +173,11 @@ export const generateValueSpecificationForParameter = (
         const enumValueRef = EnumValueExplicitReference.create(
           type.values[0] as Enum,
         );
-        instanceValue_setValues(enumValueInstanceValue, [enumValueRef]);
+        instanceValue_setValues(
+          enumValueInstanceValue,
+          [enumValueRef],
+          observerContext,
+        );
       }
       return enumValueInstanceValue;
     }
@@ -213,6 +216,7 @@ const fillDerivedPropertyParameterValues = (
           parameter,
           derivedPropertyExpressionState.queryBuilderState.graphManagerState
             .graph,
+          derivedPropertyExpressionState.queryBuilderState.observerContext,
         ),
     );
   });
@@ -224,7 +228,7 @@ const fillDerivedPropertyParameterValues = (
       ),
       ...parameterValues,
     ],
-    derivedPropertyExpressionState.queryBuilderState.observableContext,
+    derivedPropertyExpressionState.queryBuilderState.observerContext,
   );
 };
 
@@ -246,7 +250,7 @@ export class QueryBuilderDerivedPropertyExpressionState {
     this.title = getPropertyChainName(propertyExpression, true);
     this.propertyExpression = observe_AbstractPropertyExpression(
       propertyExpression,
-      queryBuilderState.observableContext,
+      queryBuilderState.observerContext,
     );
     this.queryBuilderState = queryBuilderState;
     this.derivedProperty = guaranteeType(
@@ -341,7 +345,7 @@ export class QueryBuilderPropertyExpressionState implements Hashable {
     this.queryBuilderState = queryBuilderState;
     this.propertyExpression = observe_AbstractPropertyExpression(
       propertyExpression,
-      queryBuilderState.observableContext,
+      queryBuilderState.observerContext,
     );
     this.path = getPropertyPath(propertyExpression);
     this.title = getPropertyChainName(propertyExpression, true);

package/src/stores/QueryBuilderState.ts

@@ -61,6 +61,7 @@ import {
   isStubbed_RawLambda,
   buildLambdaVariableExpressions,
   buildRawLambdaFromLambdaFunction,
+  type ValueSpecification,
 } from '@finos/legend-graph';
 import { buildLambdaFunction } from './QueryBuilderValueSpecificationBuilder.js';
 import type {
@@ -85,7 +86,7 @@ export abstract class QueryBuilderState implements CommandRegistrar {
 
   readonly changeDetectionState: QueryBuilderChangeDetectionState;
   readonly queryCompileState = ActionState.create();
-  readonly observableContext: ObserverContext;
+  readonly observerContext: ObserverContext;
 
   explorerState: QueryBuilderExplorerState;
   functionsExplorerState: QueryFunctionsExplorerState;
@@ -158,8 +159,6 @@ export abstract class QueryBuilderState implements CommandRegistrar {
 
       resetQueryResult: action,
       resetQueryContent: action,
-      resetQueryBodyContent: action,
-      resetQueryParameterContent: action,
       changeClass: action,
       changeMapping: action,
 
@@ -184,7 +183,7 @@ export abstract class QueryBuilderState implements CommandRegistrar {
     this.resultState = new QueryBuilderResultState(this);
     this.textEditorState = new QueryBuilderTextEditorState(this);
     this.unsupportedQueryState = new QueryBuilderUnsupportedQueryState(this);
-    this.observableContext = new ObserverContext(
+    this.observerContext = new ObserverContext(
       this.graphManagerState.pluginManager.getPureGraphManagerPlugins(),
     );
     this.changeDetectionState = new QueryBuilderChangeDetectionState(this);
@@ -296,13 +295,18 @@ export abstract class QueryBuilderState implements CommandRegistrar {
     );
   }
 
-  resetQueryResult(): void {
+  resetQueryResult(options?: { preserveResult?: boolean | undefined }): void {
     const resultState = new QueryBuilderResultState(this);
     resultState.setPreviewLimit(this.resultState.previewLimit);
+    if (options?.preserveResult) {
+      resultState.setExecutionResult(this.resultState.executionResult);
+      resultState.setExecutionDuration(this.resultState.executionDuration);
+      resultState.latestRunHashCode = this.resultState.latestRunHashCode;
+    }
     this.resultState = resultState;
   }
 
-  resetQueryBodyContent(): void {
+  resetQueryContent(): void {
     this.textEditorState = new QueryBuilderTextEditorState(this);
     this.unsupportedQueryState = new QueryBuilderUnsupportedQueryState(this);
     this.milestoningState = new QueryBuilderMilestoningState(this);
@@ -316,6 +320,7 @@ export abstract class QueryBuilderState implements CommandRegistrar {
     this.explorerState.refreshTreeData();
     this.constantState = new QueryBuilderConstantsState(this);
     this.functionsExplorerState = new QueryFunctionsExplorerState(this);
+    this.parametersState = new QueryBuilderParametersState(this);
     this.filterState = new QueryBuilderFilterState(this, this.filterOperators);
     this.watermarkState = new QueryBuilderWatermarkState(this);
     this.checkEntitlementsState = new QueryBuilderCheckEntitlementsState(this);
@@ -333,15 +338,6 @@ export abstract class QueryBuilderState implements CommandRegistrar {
     }
   }
 
-  resetQueryParameterContent(): void {
-    this.parametersState = new QueryBuilderParametersState(this);
-  }
-
-  resetQueryContent(): void {
-    this.resetQueryParameterContent();
-    this.resetQueryBodyContent();
-  }
-
   changeClass(val: Class): void {
     this.resetQueryResult();
     this.resetQueryContent();
@@ -386,18 +382,34 @@ export abstract class QueryBuilderState implements CommandRegistrar {
   }
 
   initializeWithQuery(query: RawLambda): void {
-    this.resetQueryParameterContent();
     this.rebuildWithQuery(query);
+    this.resetQueryResult();
     this.changeDetectionState.initialize(query);
   }
 
   /**
    * Process the provided query, and rebuild the query builder state.
    */
-  rebuildWithQuery(query: RawLambda): void {
+  rebuildWithQuery(
+    query: RawLambda,
+    options?: {
+      preserveParameterValues?: boolean | undefined;
+      preserveResult?: boolean | undefined;
+    },
+  ): void {
+    const previousStateParameterValues = new Map<
+      VariableExpression,
+      ValueSpecification | undefined
+    >();
     try {
-      this.resetQueryResult();
-      this.resetQueryBodyContent();
+      if (options?.preserveParameterValues) {
+        // Preserving parameter values
+        this.parametersState.parameterStates.forEach((ps) => {
+          previousStateParameterValues.set(ps.parameter, ps.value);
+        });
+      }
+      this.resetQueryResult({ preserveResult: options?.preserveResult });
+      this.resetQueryContent();
 
       if (!isStubbed_RawLambda(query)) {
         const valueSpec = observe_ValueSpecification(
@@ -407,7 +419,7 @@ export abstract class QueryBuilderState implements CommandRegistrar {
             ),
             this.graphManagerState.graph,
           ),
-          this.observableContext,
+          this.observerContext,
         );
         const compiledValueSpecification = guaranteeType(
           valueSpec,
@@ -417,6 +429,7 @@ export abstract class QueryBuilderState implements CommandRegistrar {
         processQueryLambdaFunction(
           guaranteeNonNullable(compiledValueSpecification.values[0]),
           this,
+          previousStateParameterValues,
         );
       }
       if (this.parametersState.parameterStates.length > 0) {
@@ -424,8 +437,8 @@ export abstract class QueryBuilderState implements CommandRegistrar {
       }
     } catch (error) {
       assertErrorThrown(error);
-      this.resetQueryBodyContent();
       this.resetQueryResult();
+      this.resetQueryContent();
       this.unsupportedQueryState.setLambdaError(error);
       this.unsupportedQueryState.setRawLambda(query);
       this.setClass(undefined);
@@ -433,9 +446,7 @@ export abstract class QueryBuilderState implements CommandRegistrar {
         query,
         this.graphManagerState,
       )
-        .map((param) =>
-          observe_ValueSpecification(param, this.observableContext),
-        )
+        .map((param) => observe_ValueSpecification(param, this.observerContext))
         .filter(filterByType(VariableExpression));
       processParameters(parameters, this);
     }

package/src/stores/QueryBuilderStateBuilder.ts

@@ -70,7 +70,6 @@ import { processTDS_OLAPGroupByExpression } from './fetch-structure/tds/window/Q
 import { processWatermarkExpression } from './watermark/QueryBuilderWatermarkStateBuilder.js';
 import { QueryBuilderConstantExpressionState } from './QueryBuilderConstantsState.js';
 import { checkIfEquivalent } from './milestoning/QueryBuilderMilestoningHelper.js';
-import { QueryBuilderParametersState } from './QueryBuilderParametersState.js';
 
 const processGetAllExpression = (
   expression: SimpleFunctionExpression,
@@ -608,28 +607,29 @@ export class QueryBuilderValueSpecificationProcessor
 export const processParameters = (
   parameters: VariableExpression[],
   queryBuilderState: QueryBuilderState,
+  parameterValues?: Map<VariableExpression, ValueSpecification | undefined>,
 ): void => {
-  const queryParameterState = new QueryBuilderParametersState(
-    queryBuilderState,
-  );
-  // Here we won't process the parameters which are present in the previous state
-  // because we don't want to lose the parameter value
+  const queryParameterState = queryBuilderState.parametersState;
   parameters.forEach((parameter) => {
-    const oldParamterState =
-      queryBuilderState.parametersState.parameterStates.find((ps) =>
-        checkIfEquivalent(ps.parameter, parameter),
-      );
-    if (oldParamterState) {
-      queryParameterState.addParameter(oldParamterState);
+    let matchingParameterValue: ValueSpecification | undefined;
+    if (parameterValues) {
+      Array.from(parameterValues.entries()).forEach(([key, value]) => {
+        if (checkIfEquivalent(key, parameter)) {
+          matchingParameterValue = value;
+        }
+      });
+    }
+    const parameterState = new LambdaParameterState(
+      parameter,
+      queryBuilderState.observerContext,
+      queryBuilderState.graphManagerState.graph,
+    );
+    if (matchingParameterValue) {
+      parameterState.setValue(matchingParameterValue);
     } else {
-      const parameterState = new LambdaParameterState(
-        parameter,
-        queryBuilderState.observableContext,
-        queryBuilderState.graphManagerState.graph,
-      );
       parameterState.mockParameterValue();
-      queryParameterState.addParameter(parameterState);
     }
+    queryParameterState.addParameter(parameterState);
   });
   queryBuilderState.parametersState = queryParameterState;
 };
@@ -637,11 +637,13 @@ export const processParameters = (
 export const processQueryLambdaFunction = (
   lambdaFunction: LambdaFunction,
   queryBuilderState: QueryBuilderState,
+  parameterValues?: Map<VariableExpression, ValueSpecification | undefined>,
 ): void => {
   if (lambdaFunction.functionType.parameters.length) {
     processParameters(
       lambdaFunction.functionType.parameters,
       queryBuilderState,
+      parameterValues,
     );
   }
   lambdaFunction.expressionSequence.map((expression) =>