@finos/legend-application-query 5.0.0 → 5.1.0

package/src/stores/QueryBuilderOperatorLoader.ts

@@ -0,0 +1,133 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+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 {
+  QueryBuilderFilterOperator_Equal,
+  QueryBuilderFilterOperator_NotEqual,
+} from './filterOperators/QueryBuilderFilterOperator_Equal.js';
+import { QueryBuilderFilterOperator_GreaterThan } from './filterOperators/QueryBuilderFilterOperator_GreaterThan.js';
+import {
+  QueryBuilderFilterOperator_NotStartWith,
+  QueryBuilderFilterOperator_StartWith,
+} from './filterOperators/QueryBuilderFilterOperator_StartWith.js';
+import { QueryBuilderFilterOperator_GreaterThanEqual } from './filterOperators/QueryBuilderFilterOperator_GreaterThanEqual.js';
+import { QueryBuilderFilterOperator_LessThanEqual } from './filterOperators/QueryBuilderFilterOperator_LessThanEqual.js';
+import { QueryBuilderFilterOperator_LessThan } from './filterOperators/QueryBuilderFilterOperator_LessThan.js';
+import {
+  QueryBuilderFilterOperator_EndWith,
+  QueryBuilderFilterOperator_NotEndWith,
+} from './filterOperators/QueryBuilderFilterOperator_EndWith.js';
+import {
+  QueryBuilderFilterOperator_Contain,
+  QueryBuilderFilterOperator_NotContain,
+} from './filterOperators/QueryBuilderFilterOperator_Contain.js';
+import {
+  QueryBuilderFilterOperator_IsEmpty,
+  QueryBuilderFilterOperator_IsNotEmpty,
+} from './filterOperators/QueryBuilderFilterOperator_IsEmpty.js';
+import {
+  QueryBuilderFilterOperator_In,
+  QueryBuilderFilterOperator_NotIn,
+} from './filterOperators/QueryBuilderFilterOperator_In.js';
+import {
+  QueryBuilderPostFilterOperator_In,
+  QueryBuilderPostFilterOperator_NotIn,
+} from './postFilterOperators/QueryBuilderPostFilterOperator_In.js';
+import {
+  QueryBuilderPostFilterOperator_IsEmpty,
+  QueryBuilderPostFilterOperator_IsNotEmpty,
+} from './postFilterOperators/QueryBuilderPostFilterOperator_IsEmpty.js';
+import {
+  QueryBuilderPostFilterOperator_Equal,
+  QueryBuilderPostFilterOperator_NotEqual,
+} from './postFilterOperators/QueryBuilderPostFilterOperator_Equal.js';
+import { QueryBuilderPostFilterOperator_LessThan } from './postFilterOperators/QueryBuilderPostFilterOperator_LessThan.js';
+import { QueryBuilderPostFilterOperator_LessThanEqual } from './postFilterOperators/QueryBuilderPostFilterOperator_LessThanEqual.js';
+import { QueryBuilderPostFilterOperator_GreaterThan } from './postFilterOperators/QueryBuilderPostFilterOperator_GreaterThan.js';
+import { QueryBuilderPostFilterOperator_GreaterThanEqual } from './postFilterOperators/QueryBuilderPostFilterOperator_GreaterThanEqual.js';
+import {
+  QueryBuilderPostFilterOperator_NotStartWith,
+  QueryBuilderPostFilterOperator_StartWith,
+} from './postFilterOperators/QueryBuilderPostFilterOperator_StartWith.js';
+import {
+  QueryBuilderPostFilterOperator_Contain,
+  QueryBuilderPostFilterOperator_NotContain,
+} from './postFilterOperators/QueryBuilderPostFilterOperator_Contain.js';
+import {
+  QueryBuilderPostFilterOperator_EndWith,
+  QueryBuilderPostFilterOperator_NotEndWith,
+} from './postFilterOperators/QueryBuilderPostFilterOperator_EndWith.js';
+
+export const AGGREGATION_OPERATORS = [
+  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(),
+];
+
+export const FILTER_OPERATORS = [
+  new QueryBuilderFilterOperator_Equal(),
+  new QueryBuilderFilterOperator_NotEqual(),
+  new QueryBuilderFilterOperator_LessThan(),
+  new QueryBuilderFilterOperator_LessThanEqual(),
+  new QueryBuilderFilterOperator_GreaterThan(),
+  new QueryBuilderFilterOperator_GreaterThanEqual(),
+  new QueryBuilderFilterOperator_StartWith(),
+  new QueryBuilderFilterOperator_NotStartWith(),
+  new QueryBuilderFilterOperator_Contain(),
+  new QueryBuilderFilterOperator_NotContain(),
+  new QueryBuilderFilterOperator_EndWith(),
+  new QueryBuilderFilterOperator_NotEndWith(),
+  new QueryBuilderFilterOperator_In(),
+  new QueryBuilderFilterOperator_NotIn(),
+  new QueryBuilderFilterOperator_IsEmpty(),
+  new QueryBuilderFilterOperator_IsNotEmpty(),
+];
+
+export const POST_FILTER_OPERATORS = [
+  new QueryBuilderPostFilterOperator_Equal(),
+  new QueryBuilderPostFilterOperator_NotEqual(),
+  new QueryBuilderPostFilterOperator_LessThan(),
+  new QueryBuilderPostFilterOperator_LessThanEqual(),
+  new QueryBuilderPostFilterOperator_GreaterThan(),
+  new QueryBuilderPostFilterOperator_GreaterThanEqual(),
+  new QueryBuilderPostFilterOperator_StartWith(),
+  new QueryBuilderPostFilterOperator_NotStartWith(),
+  new QueryBuilderPostFilterOperator_Contain(),
+  new QueryBuilderPostFilterOperator_NotContain(),
+  new QueryBuilderPostFilterOperator_EndWith(),
+  new QueryBuilderPostFilterOperator_NotEndWith(),
+  new QueryBuilderPostFilterOperator_In(),
+  new QueryBuilderPostFilterOperator_NotIn(),
+  new QueryBuilderPostFilterOperator_IsEmpty(),
+  new QueryBuilderPostFilterOperator_IsNotEmpty(),
+];

package/src/stores/QueryBuilderOperatorsHelper.ts

@@ -29,6 +29,7 @@ import {
   EnumValueInstanceValue,
   VariableExpression,
   AbstractPropertyExpression,
+  isSuperType,
 } from '@finos/legend-graph';
 import {
   addUniqueEntry,
@@ -189,3 +190,37 @@ export const isPropertyExpressionChainOptional = (
   }
   return isOptional;
 };
+
+export const isTypeCompatibleWithConditionValueType = (
+  type: Type | undefined,
+  conditionValueType: Type,
+): boolean => {
+  const NUMERIC_PRIMITIVE_TYPES = [
+    PRIMITIVE_TYPE.NUMBER,
+    PRIMITIVE_TYPE.INTEGER,
+    PRIMITIVE_TYPE.DECIMAL,
+    PRIMITIVE_TYPE.FLOAT,
+  ] as string[];
+  const DATE_PRIMITIVE_TYPES = [
+    PRIMITIVE_TYPE.DATE,
+    PRIMITIVE_TYPE.DATETIME,
+    PRIMITIVE_TYPE.STRICTDATE,
+    PRIMITIVE_TYPE.LATESTDATE,
+  ] as string[];
+
+  // When changing the return type for LHS, the RHS value should be adjusted accordingly.
+  return (
+    type !== undefined &&
+    // Numeric value is handled loosely because of autoboxing
+    // e.g. LHS (integer) = RHS (float) is acceptable
+    ((NUMERIC_PRIMITIVE_TYPES.includes(type.path) &&
+      NUMERIC_PRIMITIVE_TYPES.includes(conditionValueType.path)) ||
+      // Date value is handled loosely as well if the LHS is of type DateTime
+      // This is because we would simulate auto-boxing for date by altering the
+      // Pure function used for the operation
+      // e.g. LHS(DateTime) = RHS(Date) -> we use isOnDay() instead of is()
+      DATE_PRIMITIVE_TYPES.includes(type.path) ||
+      type === conditionValueType ||
+      isSuperType(conditionValueType, type))
+  );
+};

package/src/stores/QueryBuilderPostFilterState.ts

@@ -19,6 +19,7 @@ import {
   type PureModel,
   type Type,
   type ValueSpecification,
+  type ExecutionResult,
   Enumeration,
   PRIMITIVE_TYPE,
   observe_ValueSpecification,
@@ -36,6 +37,7 @@ import {
   UnsupportedOperationError,
   uuid,
   filterByType,
+  ActionState,
 } from '@finos/legend-shared';
 import {
   action,
@@ -51,11 +53,16 @@ import type { QueryBuilderAggregateColumnState } from './QueryBuilderAggregation
 import { QUERY_BUILDER_GROUP_OPERATION } from './QueryBuilderOperatorsHelper.js';
 import type { QueryBuilderPostFilterOperator } from './QueryBuilderPostFilterOperator.js';
 import {
-  type QueryBuilderProjectionColumnDragSource,
   type QueryBuilderProjectionColumnState,
+  type QueryBuilderProjectionColumnDragSource,
   QueryBuilderDerivationProjectionColumnState,
 } from './QueryBuilderProjectionState.js';
 import type { QueryBuilderState } from './QueryBuilderState.js';
+import {
+  buildProjectionColumnTypeAheadQuery,
+  buildTypeAheadOptions,
+  performTypeAhead,
+} from './QueryBuilderTypeaheadHelper.js';
 
 export enum QUERY_BUILDER_POST_FILTER_DND_TYPE {
   GROUP_CONDITION = 'GROUP_CONDITION',
@@ -262,6 +269,8 @@ export class PostFilterConditionState {
     | QueryBuilderAggregateColumnState;
   value?: ValueSpecification | undefined;
   operator: QueryBuilderPostFilterOperator;
+  typeaheadSearchResults: string[] | undefined;
+  typeaheadSearchState = ActionState.create();
 
   constructor(
     postFilterState: QueryBuilderPostFilterState,
@@ -273,11 +282,13 @@ export class PostFilterConditionState {
   ) {
     makeAutoObservable(this, {
       columnState: observable,
+      typeaheadSearchResults: observable,
       changeOperator: action,
       setColumnState: action,
       setValue: action,
       setOperator: action,
       changeColumn: flow,
+      handleTypeaheadSearch: flow,
     });
 
     this.postFilterState = postFilterState;
@@ -304,6 +315,34 @@ export class PostFilterConditionState {
     );
   }
 
+  *handleTypeaheadSearch(): GeneratorFn<void> {
+    try {
+      this.typeaheadSearchState.inProgress();
+      this.typeaheadSearchResults = undefined;
+      if (performTypeAhead(this.value)) {
+        const builderState = buildProjectionColumnTypeAheadQuery(
+          this.postFilterState.queryBuilderState,
+          this.columnState,
+          this.value,
+        );
+        const result =
+          (yield builderState.graphManagerState.graphManager.executeMapping(
+            builderState.resultState.buildExecutionRawLambda(),
+            guaranteeNonNullable(builderState.querySetupState.mapping),
+            guaranteeNonNullable(builderState.querySetupState.runtimeValue),
+            builderState.graphManagerState.graph,
+          )) as ExecutionResult;
+        this.typeaheadSearchResults = buildTypeAheadOptions(result);
+      }
+      this.typeaheadSearchState.pass();
+    } catch (error) {
+      assertErrorThrown(error);
+      this.typeaheadSearchState.fail();
+    } finally {
+      this.typeaheadSearchState.complete();
+    }
+  }
+
   changeOperator(val: QueryBuilderPostFilterOperator): void {
     this.setOperator(val);
     if (!this.operator.isCompatibleWithConditionValue(this)) {

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();
 };