@finos/legend-application-query 6.0.0 → 7.0.1

package/src/stores/query-builder/fetch-structure/projection/aggregation/QueryBuilderAggregationState.ts

@@ -1,145 +0,0 @@
-/**
- * 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 { action, makeAutoObservable } from 'mobx';
-import { uuid, deleteEntry, addUniqueEntry } from '@finos/legend-shared';
-import type { Type } from '@finos/legend-graph';
-import { DEFAULT_LAMBDA_VARIABLE_NAME } from '../../../QueryBuilderConfig.js';
-import type { QueryBuilderProjectionState } from '../QueryBuilderProjectionState.js';
-import type { QueryBuilderAggregateOperator } from './QueryBuilderAggregateOperator.js';
-import type { QueryBuilderProjectionColumnState } from '../QueryBuilderProjectionColumnState.js';
-
-export class QueryBuilderAggregateColumnState {
-  readonly uuid = uuid();
-  aggregationState: QueryBuilderAggregationState;
-  projectionColumnState: QueryBuilderProjectionColumnState;
-  lambdaParameterName: string = DEFAULT_LAMBDA_VARIABLE_NAME;
-  operator: QueryBuilderAggregateOperator;
-
-  constructor(
-    aggregationState: QueryBuilderAggregationState,
-    projectionColumnState: QueryBuilderProjectionColumnState,
-    operator: QueryBuilderAggregateOperator,
-  ) {
-    makeAutoObservable(this, {
-      uuid: false,
-      aggregationState: false,
-      setColumnState: action,
-      setLambdaParameterName: action,
-      setOperator: action,
-    });
-
-    this.aggregationState = aggregationState;
-    this.projectionColumnState = projectionColumnState;
-    this.operator = operator;
-  }
-
-  get columnName(): string {
-    return this.projectionColumnState.columnName;
-  }
-
-  setColumnState(val: QueryBuilderProjectionColumnState): void {
-    this.projectionColumnState = val;
-  }
-
-  setLambdaParameterName(val: string): void {
-    this.lambdaParameterName = val;
-  }
-
-  setOperator(val: QueryBuilderAggregateOperator): void {
-    this.operator = val;
-  }
-
-  getReturnType(): Type {
-    return this.operator.getReturnType(this);
-  }
-}
-
-export class QueryBuilderAggregationState {
-  projectionState: QueryBuilderProjectionState;
-  operators: QueryBuilderAggregateOperator[] = [];
-  columns: QueryBuilderAggregateColumnState[] = [];
-
-  constructor(
-    projectionState: QueryBuilderProjectionState,
-    operators: QueryBuilderAggregateOperator[],
-  ) {
-    makeAutoObservable(this, {
-      projectionState: false,
-      removeColumn: action,
-      addColumn: action,
-    });
-
-    this.projectionState = projectionState;
-    this.operators = operators;
-  }
-
-  removeColumn(val: QueryBuilderAggregateColumnState): void {
-    deleteEntry(this.columns, val);
-  }
-
-  addColumn(val: QueryBuilderAggregateColumnState): void {
-    addUniqueEntry(this.columns, val);
-  }
-
-  changeColumnAggregateOperator(
-    val: QueryBuilderAggregateOperator | undefined,
-    projectionColumnState: QueryBuilderProjectionColumnState,
-  ): void {
-    const aggregateColumnState = this.columns.find(
-      (column) => column.projectionColumnState === projectionColumnState,
-    );
-    const aggreateOperators = this.operators.filter((op) =>
-      op.isCompatibleWithColumn(projectionColumnState),
-    );
-    if (val) {
-      if (!aggreateOperators.includes(val)) {
-        return;
-      }
-      if (aggregateColumnState) {
-        aggregateColumnState.setOperator(val);
-      } else {
-        const newAggregateColumnState = new QueryBuilderAggregateColumnState(
-          this,
-          projectionColumnState,
-          val,
-        );
-        newAggregateColumnState.setOperator(val);
-        this.addColumn(newAggregateColumnState);
-
-        // automatically move the column to the end
-        // as aggregate column should always be the last one
-        // NOTE: unless we do `olap` aggregation
-        // See https://github.com/finos/legend-studio/issues/253
-        this.projectionState.moveColumn(
-          this.projectionState.columns.indexOf(projectionColumnState),
-          this.projectionState.columns.length - 1,
-        );
-      }
-    } else {
-      if (aggregateColumnState) {
-        // automatically move the column to the last position before the aggregate columns
-        // NOTE: `moveColumn` will take care of this placement calculation
-        this.projectionState.moveColumn(
-          this.projectionState.columns.indexOf(projectionColumnState),
-          0,
-        );
-
-        this.removeColumn(aggregateColumnState);
-      }
-    }
-  }
-}

package/src/stores/query-builder/fetch-structure/projection/aggregation/QueryBuilderAggregationStateBuilder.ts

@@ -1,228 +0,0 @@
-/**
- * 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 {
-  CollectionInstanceValue,
-  LambdaFunctionInstanceValue,
-  matchFunctionName,
-  SimpleFunctionExpression,
-  VariableExpression,
-} from '@finos/legend-graph';
-import {
-  assertTrue,
-  assertType,
-  guaranteeNonNullable,
-  guaranteeType,
-  isNonNullable,
-  returnUndefOnError,
-  UnsupportedOperationError,
-} from '@finos/legend-shared';
-import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../../../graphManager/QueryBuilderSupportedFunctions.js';
-import type { QueryBuilderState } from '../../../QueryBuilderState.js';
-import { QueryBuilderValueSpecificationProcessor } from '../../../QueryBuilderStateBuilder.js';
-import { extractNullableStringFromInstanceValue } from '../../../QueryBuilderValueSpecificationHelper.js';
-import { FETCH_STRUCTURE_IMPLEMENTATION } from '../../QueryBuilderFetchStructureImplementationState.js';
-import { QueryBuilderProjectionState } from '../QueryBuilderProjectionState.js';
-
-export const processTDSAggregateExpression = (
-  expression: SimpleFunctionExpression,
-  parentExpression: SimpleFunctionExpression | undefined,
-  queryBuilderState: QueryBuilderState,
-): void => {
-  // check parent expression
-  assertTrue(
-    Boolean(
-      parentExpression &&
-        matchFunctionName(
-          parentExpression.functionName,
-          QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_GROUP_BY,
-        ),
-    ),
-    `Can't process agg() expression: only support agg() used within a groupBy() expression`,
-  );
-
-  // check parameters
-  assertTrue(
-    expression.parametersValues.length === 2,
-    `Can't process agg() expression: agg() expects 2 arguments`,
-  );
-
-  // process column lambda
-  QueryBuilderValueSpecificationProcessor.processChild(
-    // TODO?: do we want to do more validation here for the shape of the column lambda?
-    guaranteeNonNullable(expression.parametersValues[0]),
-    expression,
-    queryBuilderState,
-  );
-
-  // build state
-  if (
-    queryBuilderState.fetchStructureState.implementation instanceof
-    QueryBuilderProjectionState
-  ) {
-    const projectionState =
-      queryBuilderState.fetchStructureState.implementation;
-    const aggregationState = projectionState.aggregationState;
-    // NOTE: since we process agg() expressions one by one, we know that the current agg()
-    // always correspond to the last column projection state, based on our processing procedure
-    const projectionColumnState = guaranteeNonNullable(
-      projectionState.columns[projectionState.columns.length - 1],
-    );
-    const aggregateLambda = expression.parametersValues[1];
-    assertType(
-      aggregateLambda,
-      LambdaFunctionInstanceValue,
-      `Can't process agg() expression: agg() expects argument #1 to be a lambda function`,
-    );
-
-    const lambdaFunc = guaranteeNonNullable(
-      aggregateLambda.values[0],
-      `Can't process agg() lambda: agg() lambda function is missing`,
-    );
-    assertTrue(
-      lambdaFunc.expressionSequence.length === 1,
-      `Can't process agg() lambda: only support agg() lambda body with 1 expression`,
-    );
-    const aggregateColumnExpression = guaranteeType(
-      lambdaFunc.expressionSequence[0],
-      SimpleFunctionExpression,
-      `Can't process agg() lambda: only support agg() lambda body with 1 expression`,
-    );
-
-    assertTrue(
-      lambdaFunc.functionType.parameters.length === 1,
-      `Can't process agg() lambda: only support agg() lambda with 1 parameter`,
-    );
-
-    const lambdaParam = guaranteeType(
-      lambdaFunc.functionType.parameters[0],
-      VariableExpression,
-      `Can't process agg() lambda: only support agg() lambda with 1 parameter`,
-    );
-
-    for (const operator of aggregationState.operators) {
-      // NOTE: this allow plugin author to either return `undefined` or throw error
-      // if there is a problem with building the lambda. Either case, the plugin is
-      // considered as not supporting the lambda.
-      const aggregateColumnState = returnUndefOnError(() =>
-        operator.buildAggregateColumnState(
-          aggregateColumnExpression,
-          lambdaParam,
-          projectionColumnState,
-        ),
-      );
-      if (aggregateColumnState) {
-        aggregationState.addColumn(aggregateColumnState);
-        return;
-      }
-    }
-    throw new UnsupportedOperationError(
-      `Can't process aggregate expression function: no compatible aggregate operator processer available from plugins`,
-    );
-  }
-};
-
-export const processTDSGroupByExpression = (
-  expression: SimpleFunctionExpression,
-  queryBuilderState: QueryBuilderState,
-): void => {
-  // update fetch-structure
-  queryBuilderState.fetchStructureState.changeImplementation(
-    FETCH_STRUCTURE_IMPLEMENTATION.PROJECTION,
-  );
-
-  // check parameters
-  assertTrue(
-    expression.parametersValues.length === 4,
-    `Can't process groupBy() expression: groupBy() expects 3 arguments`,
-  );
-
-  // check preceding expression
-  const precedingExpression = guaranteeType(
-    expression.parametersValues[0],
-    SimpleFunctionExpression,
-    `Can't process groupBy() expression: only support groupBy() immediately following an expression`,
-  );
-  assertTrue(
-    matchFunctionName(precedingExpression.functionName, [
-      QUERY_BUILDER_SUPPORTED_FUNCTIONS.GET_ALL,
-      QUERY_BUILDER_SUPPORTED_FUNCTIONS.FILTER,
-    ]),
-    `Can't process groupBy() expression: only support groupBy() immediately following either getAll() or filter()`,
-  );
-  QueryBuilderValueSpecificationProcessor.process(
-    precedingExpression,
-    queryBuilderState,
-  );
-
-  // process columns
-  const columnExpressions = expression.parametersValues[1];
-  assertType(
-    columnExpressions,
-    CollectionInstanceValue,
-    `Can't process groupBy() expression: groupBy() expects argument #1 to be a collection`,
-  );
-  columnExpressions.values.map((value) =>
-    QueryBuilderValueSpecificationProcessor.processChild(
-      value,
-      expression,
-      queryBuilderState,
-    ),
-  );
-
-  // process aggregations
-  const aggregateLambdas = expression.parametersValues[2];
-  assertType(
-    aggregateLambdas,
-    CollectionInstanceValue,
-    `Can't process groupBy() expression: groupBy() expects argument #2 to be a collection`,
-  );
-  aggregateLambdas.values.map((value) =>
-    QueryBuilderValueSpecificationProcessor.processChild(
-      value,
-      expression,
-      queryBuilderState,
-    ),
-  );
-
-  // process column aliases
-  const columnAliases = expression.parametersValues[3];
-  assertType(
-    columnAliases,
-    CollectionInstanceValue,
-    `Can't process groupBy() expression: groupBy() expects argument #3 to be a collection`,
-  );
-  assertTrue(
-    columnAliases.values.length ===
-      columnExpressions.values.length + aggregateLambdas.values.length,
-    `Can't process groupBy() expression: number of aliases does not match the number of columns`,
-  );
-  const aliases = columnAliases.values
-    .map(extractNullableStringFromInstanceValue)
-    .filter(isNonNullable);
-
-  // build state
-  if (
-    queryBuilderState.fetchStructureState.implementation instanceof
-    QueryBuilderProjectionState
-  ) {
-    const projectionState =
-      queryBuilderState.fetchStructureState.implementation;
-    projectionState.columns.forEach((column, idx) =>
-      column.setColumnName(aliases[idx] as string),
-    );
-  }
-};

package/src/stores/query-builder/fetch-structure/projection/aggregation/operators/QueryBuilderAggregateOperatorHelper.ts

@@ -1,109 +0,0 @@
-/**
- * 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 {
-  type PureModel,
-  type ValueSpecification,
-  SimpleFunctionExpression,
-  extractElementNameFromPath,
-  matchFunctionName,
-  VariableExpression,
-  TYPICAL_MULTIPLICITY_TYPE,
-} from '@finos/legend-graph';
-import { guaranteeType, assertTrue } from '@finos/legend-shared';
-import { QueryBuilderAggregateColumnState } from '../QueryBuilderAggregationState.js';
-import type { QueryBuilderProjectionColumnState } from '../../QueryBuilderProjectionColumnState.js';
-import type { QueryBuilderAggregateOperator } from '../QueryBuilderAggregateOperator.js';
-
-export const buildAggregateExpression = (
-  operatorFunctionFullPath: string,
-  graph: PureModel,
-  variableName: string,
-): ValueSpecification => {
-  const multiplicityOne = graph.getTypicalMultiplicity(
-    TYPICAL_MULTIPLICITY_TYPE.ONE,
-  );
-  const expression = new SimpleFunctionExpression(
-    extractElementNameFromPath(operatorFunctionFullPath),
-    multiplicityOne,
-  );
-  expression.parametersValues.push(
-    new VariableExpression(variableName, multiplicityOne),
-  );
-  return expression;
-};
-
-export const buildAggregateColumnState = (
-  projectionColumnState: QueryBuilderProjectionColumnState,
-  lambdaParam: VariableExpression,
-  expression: SimpleFunctionExpression,
-  operatorFunctionFullPath: string,
-  operator: QueryBuilderAggregateOperator,
-): QueryBuilderAggregateColumnState | undefined => {
-  if (matchFunctionName(expression.functionName, operatorFunctionFullPath)) {
-    const aggregateColumnState = new QueryBuilderAggregateColumnState(
-      projectionColumnState.projectionState.aggregationState,
-      projectionColumnState,
-      operator,
-    );
-    aggregateColumnState.setLambdaParameterName(lambdaParam.name);
-
-    assertTrue(
-      expression.parametersValues.length === 1,
-      `Can't process ${extractElementNameFromPath(
-        operatorFunctionFullPath,
-      )}() expression: ${extractElementNameFromPath(
-        operatorFunctionFullPath,
-      )}() expects no argument`,
-    );
-
-    // variable
-    const variableExpression = guaranteeType(
-      expression.parametersValues[0],
-      VariableExpression,
-      `Can't process ${extractElementNameFromPath(
-        operatorFunctionFullPath,
-      )}() expression: only support ${extractElementNameFromPath(
-        operatorFunctionFullPath,
-      )}() immediately following a variable expression`,
-    );
-    assertTrue(
-      aggregateColumnState.lambdaParameterName === variableExpression.name,
-      `Can't process ${extractElementNameFromPath(
-        operatorFunctionFullPath,
-      )}() expression: expects variable used in lambda body '${
-        variableExpression.name
-      }' to match lambda parameter '${
-        aggregateColumnState.lambdaParameterName
-      }'`,
-    );
-
-    // operator
-    assertTrue(
-      operator.isCompatibleWithColumn(
-        aggregateColumnState.projectionColumnState,
-      ),
-      `Can't process ${extractElementNameFromPath(
-        operatorFunctionFullPath,
-      )}() expression: property is not compatible with operator`,
-    );
-    aggregateColumnState.setOperator(operator);
-
-    return aggregateColumnState;
-  }
-
-  return undefined;
-};

package/src/stores/query-builder/fetch-structure/projection/aggregation/operators/QueryBuilderAggregateOperator_Average.ts

@@ -1,98 +0,0 @@
-/**
- * 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 {
-  PRIMITIVE_TYPE,
-  type ValueSpecification,
-  type SimpleFunctionExpression,
-  type VariableExpression,
-  type PureModel,
-  type AbstractPropertyExpression,
-  type Type,
-} from '@finos/legend-graph';
-import type { QueryBuilderAggregateColumnState } from '../QueryBuilderAggregationState.js';
-import { QueryBuilderAggregateOperator } from '../QueryBuilderAggregateOperator.js';
-import {
-  type QueryBuilderProjectionColumnState,
-  QueryBuilderSimpleProjectionColumnState,
-} from '../../QueryBuilderProjectionColumnState.js';
-import {
-  buildAggregateColumnState,
-  buildAggregateExpression,
-} from './QueryBuilderAggregateOperatorHelper.js';
-import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../../../../graphManager/QueryBuilderSupportedFunctions.js';
-
-export class QueryBuilderAggregateOperator_Average extends QueryBuilderAggregateOperator {
-  getLabel(projectionColumnState: QueryBuilderProjectionColumnState): string {
-    return 'average';
-  }
-
-  isCompatibleWithColumn(
-    projectionColumnState: QueryBuilderProjectionColumnState,
-  ): boolean {
-    if (
-      projectionColumnState instanceof QueryBuilderSimpleProjectionColumnState
-    ) {
-      const propertyType =
-        projectionColumnState.propertyExpressionState.propertyExpression.func
-          .genericType.value.rawType;
-      return (
-        [
-          PRIMITIVE_TYPE.NUMBER,
-          PRIMITIVE_TYPE.INTEGER,
-          PRIMITIVE_TYPE.DECIMAL,
-          PRIMITIVE_TYPE.FLOAT,
-        ] as string[]
-      ).includes(propertyType.path);
-    }
-    return true;
-  }
-
-  buildAggregateExpression(
-    propertyExpression: AbstractPropertyExpression | undefined,
-    variableName: string,
-    graph: PureModel,
-  ): ValueSpecification {
-    return buildAggregateExpression(
-      QUERY_BUILDER_SUPPORTED_FUNCTIONS.AVERAGE,
-      graph,
-      variableName,
-    );
-  }
-
-  buildAggregateColumnState(
-    expression: SimpleFunctionExpression,
-    lambdaParam: VariableExpression,
-    projectionColumnState: QueryBuilderProjectionColumnState,
-  ): QueryBuilderAggregateColumnState | undefined {
-    return buildAggregateColumnState(
-      projectionColumnState,
-      lambdaParam,
-      expression,
-      QUERY_BUILDER_SUPPORTED_FUNCTIONS.AVERAGE,
-      this,
-    );
-  }
-
-  override getReturnType(
-    aggregateColumnState: QueryBuilderAggregateColumnState,
-  ): Type {
-    const graph =
-      aggregateColumnState.aggregationState.projectionState.queryBuilderState
-        .graphManagerState.graph;
-    return graph.getType(PRIMITIVE_TYPE.FLOAT);
-  }
-}

package/src/stores/query-builder/fetch-structure/projection/aggregation/operators/QueryBuilderAggregateOperator_Count.ts

@@ -1,106 +0,0 @@
-/**
- * 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 {
-  PRIMITIVE_TYPE,
-  type Type,
-  type ValueSpecification,
-  type SimpleFunctionExpression,
-  type VariableExpression,
-  type PureModel,
-  type AbstractPropertyExpression,
-  Enumeration,
-} from '@finos/legend-graph';
-import type { QueryBuilderAggregateColumnState } from '../QueryBuilderAggregationState.js';
-import { QueryBuilderAggregateOperator } from '../QueryBuilderAggregateOperator.js';
-import {
-  type QueryBuilderProjectionColumnState,
-  QueryBuilderSimpleProjectionColumnState,
-} from '../../QueryBuilderProjectionColumnState.js';
-import {
-  buildAggregateColumnState,
-  buildAggregateExpression,
-} from './QueryBuilderAggregateOperatorHelper.js';
-import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../../../../graphManager/QueryBuilderSupportedFunctions.js';
-
-export class QueryBuilderAggregateOperator_Count extends QueryBuilderAggregateOperator {
-  getLabel(projectionColumnState: QueryBuilderProjectionColumnState): string {
-    return 'count';
-  }
-
-  isCompatibleWithColumn(
-    projectionColumnState: QueryBuilderProjectionColumnState,
-  ): boolean {
-    if (
-      projectionColumnState instanceof QueryBuilderSimpleProjectionColumnState
-    ) {
-      const propertyType =
-        projectionColumnState.propertyExpressionState.propertyExpression.func
-          .genericType.value.rawType;
-      return (
-        (
-          [
-            PRIMITIVE_TYPE.STRING,
-            PRIMITIVE_TYPE.BOOLEAN,
-            PRIMITIVE_TYPE.NUMBER,
-            PRIMITIVE_TYPE.INTEGER,
-            PRIMITIVE_TYPE.DECIMAL,
-            PRIMITIVE_TYPE.FLOAT,
-            PRIMITIVE_TYPE.DATE,
-            PRIMITIVE_TYPE.STRICTDATE,
-            PRIMITIVE_TYPE.DATETIME,
-          ] as string[]
-        ).includes(propertyType.path) || propertyType instanceof Enumeration
-      );
-    }
-    return true;
-  }
-
-  buildAggregateExpression(
-    propertyExpression: AbstractPropertyExpression | undefined,
-    variableName: string,
-    graph: PureModel,
-  ): ValueSpecification {
-    return buildAggregateExpression(
-      QUERY_BUILDER_SUPPORTED_FUNCTIONS.COUNT,
-      graph,
-      variableName,
-    );
-  }
-
-  buildAggregateColumnState(
-    expression: SimpleFunctionExpression,
-    lambdaParam: VariableExpression,
-    projectionColumnState: QueryBuilderProjectionColumnState,
-  ): QueryBuilderAggregateColumnState | undefined {
-    return buildAggregateColumnState(
-      projectionColumnState,
-      lambdaParam,
-      expression,
-      QUERY_BUILDER_SUPPORTED_FUNCTIONS.COUNT,
-      this,
-    );
-  }
-
-  override getReturnType(
-    aggregateColumnState: QueryBuilderAggregateColumnState,
-  ): Type {
-    const graph =
-      aggregateColumnState.aggregationState.projectionState.queryBuilderState
-        .graphManagerState.graph;
-    return graph.getType(PRIMITIVE_TYPE.INTEGER);
-  }
-}