@finos/legend-query-builder 4.18.8 → 4.18.9

package/src/stores/fetch-structure/tds/projection/QueryBuilderProjectionValueSpecificationBuilder.ts

@@ -18,9 +18,13 @@ import {
   type LambdaFunction,
   type ValueSpecification,
   CollectionInstanceValue,
+  ColSpec,
+  ColSpecArray,
+  ColSpecArrayInstance,
   extractElementNameFromPath,
   GenericType,
   GenericTypeExplicitReference,
+  Multiplicity,
   PrimitiveInstanceValue,
   SimpleFunctionExpression,
   INTERNAL__UnknownValueSpecification,
@@ -40,7 +44,10 @@ import {
   QueryBuilderDerivationProjectionColumnState,
   QueryBuilderSimpleProjectionColumnState,
 } from './QueryBuilderProjectionColumnState.js';
-import type { QueryBuilderTDSState } from '../QueryBuilderTDSState.js';
+import {
+  type QueryBuilderTDSState,
+  TDS_PROJECTION_MODE,
+} from '../QueryBuilderTDSState.js';
 import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../../graph/QueryBuilderMetaModelConst.js';
 import { buildGenericLambdaFunctionInstanceValue } from '../../../QueryBuilderValueSpecificationHelper.js';
 import {
@@ -110,6 +117,161 @@ const buildProjectColFunc = (
   return colFunc;
 };
 
+const buildProjectionColumnLambda = (
+  tdsState: QueryBuilderTDSState,
+  projectionColumnState: QueryBuilderProjectionColumnState,
+  options?: LambdaFunctionBuilderOption,
+): ValueSpecification => {
+  if (
+    projectionColumnState instanceof QueryBuilderSimpleProjectionColumnState
+  ) {
+    return buildGenericLambdaFunctionInstanceValue(
+      [projectionColumnState.lambdaParameterName],
+      [
+        buildPropertyExpressionChain(
+          projectionColumnState.propertyExpressionState.propertyExpression,
+          projectionColumnState.propertyExpressionState.queryBuilderState,
+          projectionColumnState.lambdaParameterName,
+          options,
+        ),
+      ],
+      tdsState.queryBuilderState.graphManagerState.graph,
+    );
+  }
+  if (
+    projectionColumnState instanceof QueryBuilderDerivationProjectionColumnState
+  ) {
+    return new INTERNAL__UnknownValueSpecification(
+      V1_serializeRawValueSpecification(
+        V1_transformRawLambda(
+          projectionColumnState.lambda,
+          new V1_GraphTransformerContextBuilder(
+            // TODO?: do we need to include the plugins here?
+            [],
+          )
+            .withKeepSourceInformationFlag(
+              Boolean(options?.keepSourceInformation),
+            )
+            .build(),
+        ),
+      ),
+    );
+  }
+  throw new UnsupportedOperationError(
+    `Can't build project() column expression: unsupported projection column state`,
+    projectionColumnState,
+  );
+};
+
+/**
+ * Standard form: `precedingExpr->project([x|..., x|...], ['a','b'])`
+ */
+const buildProjectExpression = (
+  tdsState: QueryBuilderTDSState,
+  precedingExpression: ValueSpecification,
+  options?: LambdaFunctionBuilderOption,
+): SimpleFunctionExpression => {
+  const queryBuilderState = tdsState.queryBuilderState;
+  const projectFunction = new SimpleFunctionExpression(
+    extractElementNameFromPath(QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_PROJECT),
+  );
+  const colLambdas = new CollectionInstanceValue(
+    queryBuilderState.graphManagerState.graph.getMultiplicity(
+      tdsState.projectionColumns.length,
+      tdsState.projectionColumns.length,
+    ),
+  );
+  const colAliases = new CollectionInstanceValue(
+    queryBuilderState.graphManagerState.graph.getMultiplicity(
+      tdsState.projectionColumns.length,
+      tdsState.projectionColumns.length,
+    ),
+  );
+  tdsState.projectionColumns.forEach((projectionColumnState) => {
+    const colAlias = new PrimitiveInstanceValue(
+      GenericTypeExplicitReference.create(
+        new GenericType(PrimitiveType.STRING),
+      ),
+    );
+    colAlias.values.push(projectionColumnState.columnName);
+    colAliases.values.push(colAlias);
+    colLambdas.values.push(
+      buildProjectionColumnLambda(tdsState, projectionColumnState, options),
+    );
+  });
+  projectFunction.parametersValues = [
+    precedingExpression,
+    colLambdas,
+    colAliases,
+  ];
+  return projectFunction;
+};
+
+/**
+ * Col-func form: `precedingExpr->project([col(x|..., 'a'), col(x|..., 'b')])`
+ */
+const buildProjectColExpression = (
+  tdsState: QueryBuilderTDSState,
+  precedingExpression: ValueSpecification,
+  options?: LambdaFunctionBuilderOption,
+): SimpleFunctionExpression => {
+  const queryBuilderState = tdsState.queryBuilderState;
+  const projectFunction = new SimpleFunctionExpression(
+    extractElementNameFromPath(QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_PROJECT),
+  );
+  const colFuncCollection = new CollectionInstanceValue(
+    queryBuilderState.graphManagerState.graph.getMultiplicity(
+      tdsState.projectionColumns.length,
+      tdsState.projectionColumns.length,
+    ),
+  );
+  tdsState.projectionColumns.forEach((projectionColumnState) => {
+    colFuncCollection.values.push(
+      buildProjectColFunc(tdsState, projectionColumnState, options),
+    );
+  });
+  projectFunction.parametersValues = [precedingExpression, colFuncCollection];
+  return projectFunction;
+};
+
+/**
+ * Relation-style column selection: `precedingExpr->select(~[a, b])`.
+ *
+ * Only valid when every projection column is a simple reference to an
+ * existing relation column (no derivations / no property chains).
+ */
+const buildSelectExpression = (
+  tdsState: QueryBuilderTDSState,
+  precedingExpression: ValueSpecification,
+): SimpleFunctionExpression => {
+  const selectFunction = new SimpleFunctionExpression(
+    extractElementNameFromPath(
+      QUERY_BUILDER_SUPPORTED_FUNCTIONS.RELATION_SELECT,
+    ),
+  );
+  const colSpecArrayInstance = new ColSpecArrayInstance(
+    Multiplicity.ONE,
+    undefined,
+  );
+  const colSpecArray = new ColSpecArray();
+  colSpecArrayInstance.values = [colSpecArray];
+  tdsState.projectionColumns.forEach((projectionColumnState) => {
+    if (
+      projectionColumnState instanceof
+      QueryBuilderDerivationProjectionColumnState
+    ) {
+      throw new UnsupportedOperationError(
+        `Can't build select(~[...]) expression: derivation column '${projectionColumnState.columnName}' is not supported in SELECT mode`,
+      );
+    }
+    const colSpec = new ColSpec();
+    colSpec.name = projectionColumnState.columnName;
+    colSpecArray.colSpecs.push(colSpec);
+  });
+  selectFunction.parametersValues = [precedingExpression, colSpecArrayInstance];
+  return selectFunction;
+};
+
 export const appendProjection = (
   tdsState: QueryBuilderTDSState,
   lambdaFunction: LambdaFunction,
@@ -297,117 +459,57 @@ export const appendProjection = (
     ];
     lambdaFunction.expressionSequence[0] = groupByFunction;
   } else if (tdsState.projectionColumns.length) {
-    if (!queryBuilderState.useRelation) {
-      // projection
-      const projectFunction = new SimpleFunctionExpression(
-        extractElementNameFromPath(
-          QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_PROJECT,
-        ),
-      );
-      if (tdsState.useColFunc) {
-        const colFuncCollection = new CollectionInstanceValue(
-          queryBuilderState.graphManagerState.graph.getMultiplicity(
-            tdsState.projectionColumns.length,
-            tdsState.projectionColumns.length,
-          ),
-        );
-        tdsState.projectionColumns.forEach((projectionColumnState) => {
-          colFuncCollection.values.push(
-            buildProjectColFunc(tdsState, projectionColumnState, options),
+    switch (tdsState.resolveProjectionMode) {
+      case TDS_PROJECTION_MODE.PROJECT: {
+        if (queryBuilderState.useRelation) {
+          const projectFunction = buildRelationProjection(
+            precedingExpression,
+            tdsState,
+            options,
           );
-        });
-        projectFunction.parametersValues = [
+          const aggregationFunction = tdsState.aggregationState.columns.length
+            ? buildRelationAggregation(projectFunction, tdsState)
+            : null;
+          lambdaFunction.expressionSequence[0] =
+            aggregationFunction ?? projectFunction;
+        } else {
+          lambdaFunction.expressionSequence[0] = buildProjectExpression(
+            tdsState,
+            precedingExpression,
+            options,
+          );
+        }
+        break;
+      }
+      case TDS_PROJECTION_MODE.PROJECT_COL: {
+        if (queryBuilderState.useRelation) {
+          throw new UnsupportedOperationError(
+            `Can't build projection: '${TDS_PROJECTION_MODE.PROJECT_COL}' mode is not supported with relation queries`,
+          );
+        }
+        lambdaFunction.expressionSequence[0] = buildProjectColExpression(
+          tdsState,
           precedingExpression,
-          colFuncCollection,
-        ];
-      } else {
-        const colLambdas = new CollectionInstanceValue(
-          queryBuilderState.graphManagerState.graph.getMultiplicity(
-            tdsState.projectionColumns.length,
-            tdsState.projectionColumns.length,
-          ),
-        );
-        const colAliases = new CollectionInstanceValue(
-          queryBuilderState.graphManagerState.graph.getMultiplicity(
-            tdsState.projectionColumns.length,
-            tdsState.projectionColumns.length,
-          ),
+          options,
         );
-        tdsState.projectionColumns.forEach((projectionColumnState) => {
-          // column alias
-          const colAlias = new PrimitiveInstanceValue(
-            GenericTypeExplicitReference.create(
-              new GenericType(PrimitiveType.STRING),
-            ),
+        break;
+      }
+      case TDS_PROJECTION_MODE.SELECT: {
+        if (!queryBuilderState.useRelation) {
+          throw new UnsupportedOperationError(
+            `Can't build projection: '${TDS_PROJECTION_MODE.SELECT}' mode requires a relation query`,
           );
-          colAlias.values.push(projectionColumnState.columnName);
-          colAliases.values.push(colAlias);
-
-          // column projection
-          let columnLambda: ValueSpecification;
-          if (
-            projectionColumnState instanceof
-            QueryBuilderSimpleProjectionColumnState
-          ) {
-            columnLambda = buildGenericLambdaFunctionInstanceValue(
-              [projectionColumnState.lambdaParameterName],
-              [
-                buildPropertyExpressionChain(
-                  projectionColumnState.propertyExpressionState
-                    .propertyExpression,
-                  projectionColumnState.propertyExpressionState
-                    .queryBuilderState,
-                  projectionColumnState.lambdaParameterName,
-                  options,
-                ),
-              ],
-              queryBuilderState.graphManagerState.graph,
-            );
-          } else if (
-            projectionColumnState instanceof
-            QueryBuilderDerivationProjectionColumnState
-          ) {
-            columnLambda = new INTERNAL__UnknownValueSpecification(
-              V1_serializeRawValueSpecification(
-                V1_transformRawLambda(
-                  projectionColumnState.lambda,
-                  new V1_GraphTransformerContextBuilder(
-                    // TODO?: do we need to include the plugins here?
-                    [],
-                  )
-                    .withKeepSourceInformationFlag(
-                      Boolean(options?.keepSourceInformation),
-                    )
-                    .build(),
-                ),
-              ),
-            );
-          } else {
-            throw new UnsupportedOperationError(
-              `Can't build project() column expression: unsupported projection column state`,
-              projectionColumnState,
-            );
-          }
-          colLambdas.values.push(columnLambda);
-        });
-        projectFunction.parametersValues = [
+        }
+        lambdaFunction.expressionSequence[0] = buildSelectExpression(
+          tdsState,
           precedingExpression,
-          colLambdas,
-          colAliases,
-        ];
+        );
+        break;
       }
-      lambdaFunction.expressionSequence[0] = projectFunction;
-    } else {
-      const projectFunction = buildRelationProjection(
-        precedingExpression,
-        tdsState,
-        options,
-      );
-      const aggregationFunction = tdsState.aggregationState.columns.length
-        ? buildRelationAggregation(projectFunction, tdsState)
-        : null;
-      lambdaFunction.expressionSequence[0] =
-        aggregationFunction ?? projectFunction;
+      default:
+        throw new UnsupportedOperationError(
+          `Can't build projection: unsupported projection mode '${tdsState.projectionMode}'`,
+        );
     }
   }
   // build olapGroupBy

package/src/stores/workflows/dataProduct/DataProductQueryBuilderState.ts

@@ -54,8 +54,7 @@ import {
   GenericTypeExplicitReference,
   findLakehouseAccessPointGroup,
   type PureModel,
-  V1_RelationType,
-  V1_getGenericTypeFullPath,
+  V1_buildRelationTypeFromAccessPointImplementation,
   LegendSDLC,
   DataProductAccessType,
 } from '@finos/legend-graph';
@@ -92,7 +91,6 @@ export const resolveDataProductAccessor = (
   artifact: V1_DataProductArtifact | undefined,
   relationMetadata?: RelationTypeMetadata | undefined,
 ): DataProductAccessor => {
-  const relationType = new RelationType(accessPoint.title ?? accessPoint.id);
   if (artifact) {
     const artifactGroup = artifact.accessPointGroups.find((apg) =>
       apg.accessPointImplementations.some(
@@ -102,30 +100,25 @@ export const resolveDataProductAccessor = (
     const artifactImpl = artifactGroup?.accessPointImplementations.find(
       (apImpl) => apImpl.id === accessPoint.id,
     );
-    const v1RelationType = artifactImpl?.lambdaGenericType?.typeArguments
-      .map((typeArg) => typeArg.rawType)
-      .find((rawType) => rawType instanceof V1_RelationType);
-    if (v1RelationType) {
-      relationType.columns = v1RelationType.columns.map(
-        (col) =>
-          new RelationColumn(
-            col.name,
-            GenericTypeExplicitReference.create(
-              new GenericType(
-                graph.getType(V1_getGenericTypeFullPath(col.genericType)),
-              ),
-            ),
-          ),
-      );
-      return new DataProductAccessor(
-        dataProduct.path,
-        artifactGroup?.id,
-        accessPoint.id,
-        relationType,
-        dataProduct,
-      );
+    if (artifactImpl) {
+      const builtRelationType =
+        V1_buildRelationTypeFromAccessPointImplementation(
+          artifactImpl,
+          graph,
+          accessPoint.title ?? accessPoint.id,
+        );
+      if (builtRelationType) {
+        return new DataProductAccessor(
+          dataProduct.path,
+          artifactGroup?.id,
+          accessPoint.id,
+          builtRelationType,
+          dataProduct,
+        );
+      }
     }
   }
+  const relationType = new RelationType(accessPoint.title ?? accessPoint.id);
   if (relationMetadata) {
     relationType.columns = relationMetadata.columns.map(
       (col) =>
@@ -271,7 +264,9 @@ export class ModelAccessPointDataProductExecutionState extends DataProductExecut
 
   changeSelectedRuntime(val: PackageableRuntime): void {
     this.selectedRuntime = val;
-    this.queryBuilderState.changeRuntime(val);
+    this.queryBuilderState.changeRuntime(
+      new RuntimePointer(PackageableElementExplicitReference.create(val)),
+    );
   }
 
   withAdhocRuntime(): ModelAccessPointDataProductExecutionState {
@@ -312,13 +307,19 @@ export class LakehouseDataProductExecutionState extends DataProductExecutionStat
     super(executionState, queryBuilderState);
     makeObservable(this, {
       withAdhocRuntime: observable,
+      selectedRuntime: observable,
+      changeSelectedRuntime: action,
+      compatibleRuntimes: computed,
+      showRuntimeOptions: computed,
     });
     this.selectedRuntime = this.compatibleRuntimes[0];
   }
 
   changeSelectedRuntime(val: PackageableRuntime): void {
     this.selectedRuntime = val;
-    this.queryBuilderState.changeRuntime(val);
+    this.queryBuilderState.changeRuntime(
+      new RuntimePointer(PackageableElementExplicitReference.create(val)),
+    );
   }
 
   withAdhocRuntime(): LakehouseDataProductExecutionState {