@finos/legend-application-query 5.0.2 → 5.1.0

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,30 +68,22 @@ 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',
@@ -380,7 +372,10 @@ export class QueryBuilderProjectionState {
   aggregationState: QueryBuilderAggregationState;
   isConvertDerivationProjectionObjects = false;
 
-  constructor(queryBuilderState: QueryBuilderState) {
+  constructor(
+    queryBuilderState: QueryBuilderState,
+    operators: QueryBuilderAggregateOperator[],
+  ) {
     makeAutoObservable(this, {
       queryBuilderState: false,
       removeColumn: action,
@@ -390,18 +385,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> {
@@ -709,13 +693,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 +732,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,
@@ -795,17 +771,24 @@ export class QueryBuilderProjectionState {
   }
 
   isValidProjectionState(): boolean {
+    return Boolean(!this.getValidationErrorMessage());
+  }
+
+  getValidationErrorMessage(): string | undefined {
     if (this.queryBuilderState.fetchStructureState.isProjectionMode()) {
-      // duplicate columns check
       const hasDuplicatedProjectionColumns = this.columns.some(
         (column) =>
           this.columns.filter((c) => c.columnName === column.columnName)
             .length > 1,
       );
-      // no columns check
+      if (hasDuplicatedProjectionColumns) {
+        return 'Query has duplicated projection columns';
+      }
       const hasNoProjectionColumns = this.columns.length === 0;
-      return !hasDuplicatedProjectionColumns && !hasNoProjectionColumns;
+      if (hasNoProjectionColumns) {
+        return 'Query has no projection columns';
+      }
     }
-    return true;
+    return undefined;
   }
 }