@finos/legend-query-builder 4.17.99 → 4.18.0

package/src/components/workflows/ClassQueryBuilder.tsx

@@ -64,9 +64,9 @@ const ClassQueryBuilderSetupPanelContent = observer(
 
     // mapping
     const mappingOptions = (
-      queryBuilderState.class
+      queryBuilderState.sourceClass
         ? getClassCompatibleMappings(
-            queryBuilderState.class,
+            queryBuilderState.sourceClass,
             queryBuilderState.graphManagerState.usableMappings,
           )
         : []
@@ -79,7 +79,7 @@ const ClassQueryBuilderSetupPanelContent = observer(
       : null;
     const changeMapping = (val: PackageableElementOption<Mapping>): void => {
       if (
-        !queryBuilderState.class ||
+        !queryBuilderState.sourceElement ||
         val.value === queryBuilderState.executionContextState.mapping
       ) {
         return;
@@ -152,7 +152,7 @@ const ClassQueryBuilderSetupPanelContent = observer(
                   : 'No compatible mapping found for class'
               }
               noMatchMessage="No compatible mapping found for specified class"
-              disabled={!queryBuilderState.class}
+              disabled={!queryBuilderState.sourceElement}
               options={mappingOptions}
               onChange={changeMapping}
               value={selectedMappingOption}
@@ -182,7 +182,7 @@ const ClassQueryBuilderSetupPanelContent = observer(
               placeholder="Choose a runtime..."
               noMatchMessage="No compatible runtime found for specified mapping"
               disabled={
-                !queryBuilderState.class ||
+                !queryBuilderState.sourceElement ||
                 !queryBuilderState.executionContextState.mapping
               }
               options={runtimeOptions}

package/src/graph/QueryBuilderMetaModelConst.ts

@@ -127,6 +127,11 @@ export enum QUERY_BUILDER_SUPPORTED_FUNCTIONS {
   RELATION_SORT = 'meta::pure::functions::relation::sort',
   RELATION_SLICE = 'meta::pure::functions::relation::slice',
   RELATION_GROUP_BY = 'meta::pure::functions::relation::groupBy',
+  RELATION_EXTEND = 'meta::pure::functions::relation::extend',
+  RELATION_OVER = 'meta::pure::functions::relation::over',
+  RELATION_RANK = 'meta::pure::functions::relation::rank',
+  RELATION_DENSE_RANK = 'meta::pure::functions::relation::denseRank',
+
   // filter
   CONTAINS = 'meta::pure::functions::string::contains',
   ENDS_WITH = 'meta::pure::functions::string::endsWith',

package/src/graph-manager/protocol/pure/QueryBuilder_PureProtocolProcessorPlugin.ts

@@ -26,6 +26,8 @@ import {
   V1_buildSubTypePropertyExpressionTypeInference,
   V1_buildWatermarkFunctionExpression,
   V1_buildGroupByFunctionExpression,
+  V1_buildOverFunctionExpression,
+  V1_buildExtendFunctionExpression,
 } from './v1/V1_QueryValueSpecificationBuilderHelper.js';
 import {
   type V1_GraphBuilderContext,
@@ -237,6 +239,32 @@ export class QueryBuilder_PureProtocolProcessorPlugin extends PureProtocolProces
             new GenericType(PrimitiveType.DATE),
           );
           return expression;
+        } else if (
+          matchFunctionName(
+            functionName,
+            QUERY_BUILDER_SUPPORTED_FUNCTIONS.RELATION_EXTEND,
+          )
+        ) {
+          return V1_buildExtendFunctionExpression(
+            functionName,
+            parameters,
+            openVariables,
+            compileContext,
+            processingContext,
+          );
+        } else if (
+          matchFunctionName(
+            functionName,
+            QUERY_BUILDER_SUPPORTED_FUNCTIONS.RELATION_OVER,
+          )
+        ) {
+          return V1_buildOverFunctionExpression(
+            functionName,
+            parameters,
+            openVariables,
+            compileContext,
+            processingContext,
+          );
         } else if (
           matchFunctionName(
             functionName,

package/src/graph-manager/protocol/pure/v1/V1_QueryValueSpecificationBuilderHelper.ts

@@ -697,10 +697,6 @@ const V1_buildTypedProjectFunctionExpression = (
           GenericTypeExplicitReference.create(new GenericType(returnType)),
         ),
       );
-    } else {
-      throw new UnsupportedOperationError(
-        'Unable to get return type for current lambda',
-      );
     }
     return pColSpec;
   });
@@ -1219,6 +1215,7 @@ export const V1_buildTypedGroupByFunctionExpression = (
       .map((colSpec) => [colSpec.function1, colSpec.function2])
       .flat()
       .filter(isNonNullable)
+      .filter(filterByType(V1_Lambda))
       .map((value) => value.parameters)
       .flat();
   topLevelLambdaParameters.forEach((variable) => {
@@ -1576,3 +1573,225 @@ export const V1_buildSubTypePropertyExpressionTypeInference = (
   inferredVariable.parametersValues.filter(
     (param) => param instanceof InstanceValue,
   )[0]?.genericType?.value.rawType;
+
+export const V1_buildOverFunctionExpression = (
+  functionName: string,
+  parameters: V1_ValueSpecification[],
+  openVariables: string[],
+  compileContext: V1_GraphBuilderContext,
+  processingContext: V1_ProcessingContext,
+): SimpleFunctionExpression => {
+  assertTrue(
+    parameters.length >= 1 && parameters.length <= 2,
+    `Can't build over() expression: over() expects 1-2 arguments, got ${parameters.length}`,
+  );
+  //TODO: handle over() when first param is a ColSpec, and when only given SortInfo
+  const windowColumns = parameters[0];
+  assertType(
+    windowColumns,
+    V1_ClassInstance,
+    `Can't build over() expression with ColSpecArray: expects argument #1 to be a ClassInstance`,
+  );
+  const specArray = guaranteeType(
+    windowColumns.value,
+    V1_ColSpecArray,
+    `Can't build over() expression with ColSpecArray: expects ClassInstance to hold ColSpecArray`,
+  );
+
+  const windowColSpecArrayInst = new ColSpecArrayInstance(Multiplicity.ONE);
+  const windowColSpecArray = new ColSpecArray();
+  windowColSpecArrayInst.values = [windowColSpecArray];
+
+  windowColSpecArray.colSpecs = specArray.colSpecs.map((colSpec) => {
+    const windowColSpec = new ColSpec();
+    windowColSpec.name = colSpec.name;
+    windowColSpec.type = colSpec.type;
+    return windowColSpec;
+  });
+
+  const processedParams: ValueSpecification[] = [windowColSpecArrayInst];
+
+  if (parameters[1]) {
+    const sortBy = parameters[1].accept_ValueSpecificationVisitor(
+      new V1_ValueSpecificationBuilder(
+        compileContext,
+        processingContext,
+        openVariables,
+      ),
+    );
+    processedParams.push(sortBy);
+  }
+
+  return V1_buildBaseSimpleFunctionExpression(
+    processedParams,
+    functionName,
+    compileContext,
+  );
+};
+
+export const V1_buildExtendFunctionExpression = (
+  functionName: string,
+  parameters: V1_ValueSpecification[],
+  openVariables: string[],
+  compileContext: V1_GraphBuilderContext,
+  processingContext: V1_ProcessingContext,
+): SimpleFunctionExpression => {
+  if (parameters.length === 3) {
+    const precedingExpression = guaranteeNonNullable(
+      parameters[0],
+      `Can't build relation extend() expression: preceding expression is missing`,
+    ).accept_ValueSpecificationVisitor(
+      new V1_ValueSpecificationBuilder(
+        compileContext,
+        processingContext,
+        openVariables,
+      ),
+    );
+    assertNonNullable(
+      precedingExpression.genericType,
+      `Can't build relation extend() expression: preceding expression return type is missing`,
+    );
+
+    const overExpression = guaranteeNonNullable(
+      parameters[1],
+      `Can't build relation extend() expression: over() expression is missing`,
+    ).accept_ValueSpecificationVisitor(
+      new V1_ValueSpecificationBuilder(
+        compileContext,
+        processingContext,
+        openVariables,
+      ),
+    );
+
+    const windowOperator = guaranteeNonNullable(
+      parameters[2],
+      `Can't build relation extend() expression: window operator is missing`,
+    );
+    assertType(
+      windowOperator,
+      V1_ClassInstance,
+      `Can't build relation extend() expression: extend() expects argument #3 to be a ClassInstance`,
+    );
+
+    //TODO: handle extend() where the third parameter is a ColSpec
+    const operatorExpression = windowOperator.value as V1_ColSpecArray;
+
+    const topLevelLambdaParameters: V1_Variable[] = operatorExpression.colSpecs
+      .flatMap((colSpec) => [colSpec.function1, colSpec.function2])
+      .filter(isNonNullable)
+      .flatMap((value) => (value as V1_Lambda).parameters);
+    topLevelLambdaParameters.forEach((variable) => {
+      if (!variable.genericType) {
+        const variableExpression = new VariableExpression(
+          variable.name,
+          precedingExpression.multiplicity,
+        );
+        variableExpression.genericType = precedingExpression.genericType;
+        processingContext.addInferredVariables(
+          variable.name,
+          variableExpression,
+        );
+      }
+    });
+
+    const builtOperatorExpressions = new ColSpecArrayInstance(Multiplicity.ONE);
+    const builtOperatorColSpecArray = new ColSpecArray();
+    builtOperatorExpressions.values = [builtOperatorColSpecArray];
+
+    const precedingRelationType =
+      precedingExpression.genericType.value.typeArguments?.[0]?.value.rawType;
+    const relationType = new RelationType(RelationType.ID);
+
+    if (precedingRelationType instanceof RelationType) {
+      precedingRelationType.columns.forEach((col) => {
+        relationType.columns.push(col);
+      });
+    }
+
+    builtOperatorColSpecArray.colSpecs = operatorExpression.colSpecs.map(
+      (colSpec) => {
+        const builtColSpec = new ColSpec();
+        builtColSpec.name = colSpec.name;
+        if (colSpec.function1) {
+          const function1 = guaranteeType(
+            colSpec.function1,
+            V1_Lambda,
+            `Can't build relation extend() col spec expression: expects function1 to be a lambda`,
+          );
+
+          const function1Lambda = guaranteeType(
+            function1.accept_ValueSpecificationVisitor(
+              new V1_ValueSpecificationBuilder(
+                compileContext,
+                processingContext,
+                openVariables,
+              ),
+            ),
+            LambdaFunctionInstanceValue,
+            `Can't build relation extend() col spec expression: expected function1 to be a lambda`,
+          );
+          builtColSpec.function1 = function1Lambda;
+        }
+
+        if (colSpec.function2) {
+          const function2 = guaranteeType(
+            colSpec.function2,
+            V1_Lambda,
+            `Can't build relation extend() col spec expression: expects function2 to be a lambda`,
+          );
+          const function2Lambda = guaranteeType(
+            function2.accept_ValueSpecificationVisitor(
+              new V1_ValueSpecificationBuilder(
+                compileContext,
+                processingContext,
+                openVariables,
+              ),
+            ),
+            LambdaFunctionInstanceValue,
+            `Can't build relation extend() col spec expression: expected aggregation function to be a lambda`,
+          );
+          builtColSpec.function2 = function2Lambda;
+        }
+
+        let returnType: Type | undefined;
+        if (builtColSpec.function2) {
+          returnType = getValueSpecificationReturnType(builtColSpec.function2);
+        } else if (builtColSpec.function1) {
+          returnType = getValueSpecificationReturnType(builtColSpec.function1);
+        }
+
+        if (returnType) {
+          relationType.columns.push(
+            new RelationColumn(
+              colSpec.name,
+              GenericTypeExplicitReference.create(new GenericType(returnType)),
+            ),
+          );
+        }
+
+        return builtColSpec;
+      },
+    );
+
+    //build extend()
+    const expression = V1_buildBaseSimpleFunctionExpression(
+      [precedingExpression, overExpression, builtOperatorExpressions],
+      functionName,
+      compileContext,
+    );
+
+    const relationGenericType = new GenericType(Relation.INSTANCE);
+    const relationTypeGenericType = new GenericType(relationType);
+    relationGenericType.typeArguments = [
+      GenericTypeExplicitReference.create(relationTypeGenericType),
+    ];
+    expression.genericType =
+      GenericTypeExplicitReference.create(relationGenericType);
+
+    return expression;
+  } else {
+    throw new UnsupportedOperationError(
+      `Can't build relation extend() expression: extend() on non window functions is not yet supported`,
+    );
+  }
+};

package/src/index.ts

@@ -70,6 +70,8 @@ export {
   ModelAccessPointDataProductExecutionState,
 } from './stores/workflows/dataProduct/DataProductQueryBuilderState.js';
 export { DataProductQueryBuilderSetupFormContent } from './components/workflows/DataProductQueryBuilder.js';
+export { AccessorQueryBuilderState } from './stores/workflows/accessor/AccessorQueryBuilderState.js';
+export { getCompatibleRuntimesFromAccessorOwner } from './stores/workflows/accessor/AccessorQueryBuilderHelper.js';
 export { MappingQueryBuilderState } from './stores/workflows/MappingQueryBuilderState.js';
 export {
   type ServiceExecutionContext,

package/src/stores/QueryBuilderConfig.ts

@@ -24,6 +24,9 @@ export const DEFAULT_LAMBDA_VARIABLE_NAME = 'x';
 export const DEFAULT_VARIABLE_NAME = 'var';
 export const DEFAULT_CONSTANT_VARIABLE_NAME = 'c_var';
 export const DEFAULT_POST_FILTER_LAMBDA_VARIABLE_NAME = 'row';
+export const DEFAULT_WINDOW_FUNCTION_PARTITION_VAR_NAME = 'p';
+export const DEFAULT_WINDOW_FUNCTION_WINDOW_VAR_NAME = 'w';
+export const DEFAULT_WINDOW_FUNCTION_ROW_VAR_NAME = 'r';
 
 export const QUERY_BUILDER_PROPERTY_SEARCH_MAX_DEPTH = 10;
 export const QUERY_BUILDER_PROPERTY_SEARCH_MAX_NODES = 10000;

package/src/stores/QueryBuilderResultState.ts

@@ -224,7 +224,16 @@ export class QueryBuilderResultState {
   }
 
   addSelectedCell(val: TDSResultCellData): void {
-    this.selectedCells.push(val);
+    // Deduplicate by coordinates — Ctrl+clicking an already-selected cell
+    // must not inflate the count or corrupt statistics.
+    const alreadyPresent = this.selectedCells.some(
+      (c) =>
+        c.coordinates.rowIndex === val.coordinates.rowIndex &&
+        c.coordinates.colIndex === val.coordinates.colIndex,
+    );
+    if (!alreadyPresent) {
+      this.selectedCells.push(val);
+    }
   }
 
   setSelectedCells(val: TDSResultCellData[]): void {
@@ -473,10 +482,12 @@ export class QueryBuilderResultState {
     try {
       this.setIsRunningQuery(true);
       const currentHashCode = this.queryBuilderState.hashCode;
-      guaranteeNonNullable(
-        this.queryBuilderState.executionContextState.mapping,
-        'Mapping is required to execute query',
-      );
+      if (this.queryBuilderState.requiresMappingForExecution) {
+        guaranteeNonNullable(
+          this.queryBuilderState.executionContextState.mapping,
+          'Mapping is required to execute query',
+        );
+      }
       guaranteeNonNullable(
         this.queryBuilderState.executionContextState.runtimeValue,
         `Runtime is required to execute query`,
@@ -581,10 +592,12 @@ export class QueryBuilderResultState {
   *generatePlan(debug: boolean): GeneratorFn<void> {
     try {
       this.isGeneratingPlan = true;
-      guaranteeNonNullable(
-        this.queryBuilderState.executionContextState.mapping,
-        'Mapping is required to execute query',
-      );
+      if (this.queryBuilderState.requiresMappingForExecution) {
+        guaranteeNonNullable(
+          this.queryBuilderState.executionContextState.mapping,
+          'Mapping is required to execute query',
+        );
+      }
       guaranteeNonNullable(
         this.queryBuilderState.executionContextState.runtimeValue,
         `Runtime is required to execute query`,

package/src/stores/QueryBuilderState.ts

@@ -55,10 +55,12 @@ import {
   type PackageableElement,
   type ValueSpecification,
   type Type,
+  type RelationType,
   type QueryGridConfig,
   type QueryExecutionContext,
   type FunctionAnalysisInfo,
   type GraphData,
+  Accessor,
   GRAPH_MANAGER_EVENT,
   CompilationError,
   extractSourceInformationCoordinates,
@@ -226,7 +228,7 @@ export abstract class QueryBuilderState implements CommandRegistrar {
 
   lambdaWriteMode = QUERY_BUILDER_LAMBDA_WRITER_MODE.STANDARD;
 
-  class?: Class | undefined;
+  sourceElement?: Class | Accessor | undefined;
   getAllFunction: QUERY_BUILDER_SUPPORTED_GET_ALL_FUNCTIONS =
     QUERY_BUILDER_SUPPORTED_GET_ALL_FUNCTIONS.GET_ALL;
   executionContextState: QueryBuilderExecutionContextState;
@@ -270,7 +272,7 @@ export abstract class QueryBuilderState implements CommandRegistrar {
       changeDetectionState: observable,
       changeHistoryState: observable,
       executionContextState: observable,
-      class: observable,
+      sourceElement: observable,
       queryChatState: observable,
       isQueryChatOpened: observable,
       isLocalModeEnabled: observable,
@@ -280,9 +282,13 @@ export abstract class QueryBuilderState implements CommandRegistrar {
       INTERNAL__enableInitializingDefaultSimpleExpressionValue: observable,
 
       sideBarClassName: computed,
+      sourceClass: computed,
+      sourceAccessor: computed,
+      sourceRelationType: computed,
       isQuerySupported: computed,
       allValidationIssues: computed,
       canBuildQuery: computed,
+      useRelation: computed,
 
       setShowFunctionsExplorerPanel: action,
       setShowParametersPanel: action,
@@ -291,7 +297,7 @@ export abstract class QueryBuilderState implements CommandRegistrar {
       setDataCubeViewerState: action,
       openDataCubeEngine: action,
       setIsCheckingEntitlments: action,
-      setClass: action,
+      setSourceElement: action,
       setIsQueryChatOpened: action,
       setIsLocalModeEnabled: action,
       setGetAllFunction: action,
@@ -301,7 +307,7 @@ export abstract class QueryBuilderState implements CommandRegistrar {
 
       resetQueryResult: action,
       resetQueryContent: action,
-      changeClass: action,
+      changeSourceElement: action,
       changeMapping: action,
       changeRuntime: action,
       setExecutionContextState: action,
@@ -358,6 +364,10 @@ export abstract class QueryBuilderState implements CommandRegistrar {
     return new QueryBuilderExternalExecutionContextState(this);
   }
 
+  get useRelation(): boolean {
+    return this.sourceElement instanceof Accessor || this.isFetchStructureTyped;
+  }
+
   get isMappingReadOnly(): boolean {
     return false;
   }
@@ -415,6 +425,10 @@ export abstract class QueryBuilderState implements CommandRegistrar {
     return this.isFetchStructureTyped;
   }
 
+  get requiresMappingForExecution(): boolean {
+    return true;
+  }
+
   setLambdaWriteMode(val: QUERY_BUILDER_LAMBDA_WRITER_MODE): void {
     this.lambdaWriteMode = val;
   }
@@ -463,7 +477,7 @@ export abstract class QueryBuilderState implements CommandRegistrar {
    */
   getStateInfo(): QueryableClassMappingRuntimeInfo | undefined {
     if (this.sourceInfo) {
-      const classPath = this.class?.path;
+      const classPath = this.sourceClass?.path;
       const mappingPath = this.executionContextState.mapping?.path;
       const runtimePath =
         this.executionContextState.runtimeValue instanceof RuntimePointer
@@ -528,8 +542,29 @@ export abstract class QueryBuilderState implements CommandRegistrar {
     this.isCalendarEnabled = val;
   }
 
-  setClass(val: Class | undefined): void {
-    this.class = val;
+  /**
+   * Convenience getter that returns the class only when the source
+   * type is a Class (not a RelationType). Use this in code paths
+   * that are Class-specific (milestoning, explorer tree, graph-fetch, etc.).
+   */
+  get sourceClass(): Class | undefined {
+    return this.sourceElement instanceof Accessor
+      ? undefined
+      : this.sourceElement;
+  }
+
+  get sourceAccessor(): Accessor | undefined {
+    return this.sourceElement instanceof Accessor
+      ? this.sourceElement
+      : undefined;
+  }
+
+  get sourceRelationType(): RelationType | undefined {
+    return this.sourceAccessor?.relationType;
+  }
+
+  setSourceElement(val: Class | Accessor | undefined): void {
+    this.sourceElement = val;
   }
 
   setExecutionContextState(val: QueryBuilderExecutionContextState): void {
@@ -651,13 +686,13 @@ export abstract class QueryBuilderState implements CommandRegistrar {
     }
   }
 
-  changeClass(val: Class): void {
+  changeSourceElement(val: Class | Accessor): void {
     this.resetQueryResult();
     this.resetQueryContent();
     this.setGetAllFunction(QUERY_BUILDER_SUPPORTED_GET_ALL_FUNCTIONS.GET_ALL);
-    this.setClass(val);
+    this.setSourceElement(val);
     this.explorerState.refreshTreeData();
-    this.fetchStructureState.implementation.onClassChange(val);
+    this.fetchStructureState.implementation.onClassChange();
     this.milestoningState.updateMilestoningConfiguration();
     this.changeHistoryState.cacheNewQuery(this.buildQuery());
   }
@@ -878,7 +913,7 @@ export abstract class QueryBuilderState implements CommandRegistrar {
       this.resetQueryContent();
       this.unsupportedQueryState.setLambdaError(error);
       this.unsupportedQueryState.setRawLambda(query);
-      this.setClass(undefined);
+      this.setSourceElement(undefined);
       const parameters = buildLambdaVariableExpressions(
         query,
         this.graphManagerState,
@@ -1019,7 +1054,7 @@ export abstract class QueryBuilderState implements CommandRegistrar {
       this.workflowState,
       undefined,
     );
-    basicState.class = this.class;
+    basicState.sourceElement = this.sourceElement;
     basicState.executionContextState.mapping =
       this.executionContextState.mapping;
     basicState.executionContextState.runtimeValue =