@finos/legend-query-builder 0.0.1

package/src/stores/fetch-structure/projection/aggregation/operators/QueryBuilderAggregateOperator_Distinct.ts

@@ -0,0 +1,96 @@
+/**
+ * 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,
+  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_Distinct extends QueryBuilderAggregateOperator {
+  getLabel(projectionColumnState: QueryBuilderProjectionColumnState): string {
+    return 'distinct';
+  }
+
+  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.UNIQUE_VALUE_ONLY,
+      graph,
+      variableName,
+    );
+  }
+
+  buildAggregateColumnState(
+    expression: SimpleFunctionExpression,
+    lambdaParam: VariableExpression,
+    projectionColumnState: QueryBuilderProjectionColumnState,
+  ): QueryBuilderAggregateColumnState | undefined {
+    return buildAggregateColumnState(
+      projectionColumnState,
+      lambdaParam,
+      expression,
+      QUERY_BUILDER_SUPPORTED_FUNCTIONS.UNIQUE_VALUE_ONLY,
+      this,
+    );
+  }
+}

package/src/stores/fetch-structure/projection/aggregation/operators/QueryBuilderAggregateOperator_DistinctCount.ts

@@ -0,0 +1,173 @@
+/**
+ * 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 AbstractPropertyExpression,
+  type PureModel,
+  type ValueSpecification,
+  SimpleFunctionExpression,
+  VariableExpression,
+  TYPICAL_MULTIPLICITY_TYPE,
+  extractElementNameFromPath,
+  matchFunctionName,
+  PRIMITIVE_TYPE,
+  type Type,
+  Enumeration,
+} from '@finos/legend-graph';
+import { assertTrue, guaranteeType } from '@finos/legend-shared';
+import { QueryBuilderAggregateColumnState } from '../QueryBuilderAggregationState.js';
+import { QueryBuilderAggregateOperator } from '../QueryBuilderAggregateOperator.js';
+import {
+  type QueryBuilderProjectionColumnState,
+  QueryBuilderSimpleProjectionColumnState,
+} from '../../QueryBuilderProjectionColumnState.js';
+import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../../../graphManager/QueryBuilderSupportedFunctions.js';
+
+export class QueryBuilderAggregateOperator_DistinctCount extends QueryBuilderAggregateOperator {
+  getLabel(projectionColumnState: QueryBuilderProjectionColumnState): string {
+    return 'distinct 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 {
+    const multiplicityOne = graph.getTypicalMultiplicity(
+      TYPICAL_MULTIPLICITY_TYPE.ONE,
+    );
+    const distinctExpression = new SimpleFunctionExpression(
+      extractElementNameFromPath(QUERY_BUILDER_SUPPORTED_FUNCTIONS.DISTINCT),
+      multiplicityOne,
+    );
+    distinctExpression.parametersValues.push(
+      new VariableExpression(variableName, multiplicityOne),
+    );
+    const distinctCountExpression = new SimpleFunctionExpression(
+      extractElementNameFromPath(QUERY_BUILDER_SUPPORTED_FUNCTIONS.COUNT),
+      multiplicityOne,
+    );
+    distinctCountExpression.parametersValues.push(distinctExpression);
+    return distinctCountExpression;
+  }
+
+  buildAggregateColumnState(
+    expression: SimpleFunctionExpression,
+    lambdaParam: VariableExpression,
+    projectionColumnState: QueryBuilderProjectionColumnState,
+  ): QueryBuilderAggregateColumnState | undefined {
+    if (
+      matchFunctionName(
+        expression.functionName,
+        QUERY_BUILDER_SUPPORTED_FUNCTIONS.COUNT,
+      )
+    ) {
+      const aggregateColumnState = new QueryBuilderAggregateColumnState(
+        projectionColumnState.projectionState.aggregationState,
+        projectionColumnState,
+        this,
+      );
+      aggregateColumnState.setLambdaParameterName(lambdaParam.name);
+
+      // process count expression
+      assertTrue(
+        expression.parametersValues.length === 1,
+        `Can't process count() expression: count() expects no argument`,
+      );
+
+      // distinct expression
+      const distinctExpression = guaranteeType(
+        expression.parametersValues[0],
+        SimpleFunctionExpression,
+        `Can't process '${this.getLabel(
+          projectionColumnState,
+        )}' aggregate lambda: only support count() immediately following an expression`,
+      );
+      assertTrue(
+        matchFunctionName(
+          distinctExpression.functionName,
+          QUERY_BUILDER_SUPPORTED_FUNCTIONS.DISTINCT,
+        ),
+        `Can't process '${this.getLabel(
+          projectionColumnState,
+        )}' aggregate lambda: only support count() immediately following distinct() expression`,
+      );
+      assertTrue(
+        distinctExpression.parametersValues.length === 1,
+        `Can't process distinct() expression: distinct() expects no argument`,
+      );
+
+      // variable
+      const variableExpression = guaranteeType(
+        distinctExpression.parametersValues[0],
+        VariableExpression,
+        `Can't process distinct() expression: only support distinct() immediately following a variable expression`,
+      );
+      assertTrue(
+        aggregateColumnState.lambdaParameterName === variableExpression.name,
+        `Can't process distinct() expression: expects variable used in lambda body '${variableExpression.name}' to match lambda parameter '${aggregateColumnState.lambdaParameterName}'`,
+      );
+
+      // operator
+      assertTrue(
+        this.isCompatibleWithColumn(aggregateColumnState.projectionColumnState),
+        `Can't process disc expression: property is not compatible with operator`,
+      );
+      aggregateColumnState.setOperator(this);
+
+      return aggregateColumnState;
+    }
+
+    return undefined;
+  }
+
+  override getReturnType(
+    aggregateColumnState: QueryBuilderAggregateColumnState,
+  ): Type {
+    const graph =
+      aggregateColumnState.aggregationState.projectionState.queryBuilderState
+        .graphManagerState.graph;
+    return graph.getType(PRIMITIVE_TYPE.INTEGER);
+  }
+}

package/src/stores/fetch-structure/projection/aggregation/operators/QueryBuilderAggregateOperator_JoinString.ts

@@ -0,0 +1,155 @@
+/**
+ * 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 AbstractPropertyExpression,
+  type PureModel,
+  type ValueSpecification,
+  type Type,
+  matchFunctionName,
+  SimpleFunctionExpression,
+  VariableExpression,
+  TYPICAL_MULTIPLICITY_TYPE,
+  extractElementNameFromPath,
+  PrimitiveInstanceValue,
+  GenericTypeExplicitReference,
+  GenericType,
+  PRIMITIVE_TYPE,
+} from '@finos/legend-graph';
+import { assertTrue, guaranteeType } from '@finos/legend-shared';
+import { QueryBuilderAggregateColumnState } from '../QueryBuilderAggregationState.js';
+import { QueryBuilderAggregateOperator } from '../QueryBuilderAggregateOperator.js';
+import {
+  type QueryBuilderProjectionColumnState,
+  QueryBuilderSimpleProjectionColumnState,
+} from '../../QueryBuilderProjectionColumnState.js';
+import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../../../graphManager/QueryBuilderSupportedFunctions.js';
+
+export class QueryBuilderAggregateOperator_JoinString extends QueryBuilderAggregateOperator {
+  getLabel(projectionColumnState: QueryBuilderProjectionColumnState): string {
+    return 'join';
+  }
+
+  isCompatibleWithColumn(
+    projectionColumnState: QueryBuilderProjectionColumnState,
+  ): boolean {
+    if (
+      projectionColumnState instanceof QueryBuilderSimpleProjectionColumnState
+    ) {
+      const propertyType =
+        projectionColumnState.propertyExpressionState.propertyExpression.func
+          .genericType.value.rawType;
+      // NOTE: Engine does not support Enumerations at the moment.
+      return PRIMITIVE_TYPE.STRING === propertyType.path;
+    }
+    return true;
+  }
+
+  buildAggregateExpression(
+    propertyExpression: AbstractPropertyExpression | undefined,
+    variableName: string,
+    graph: PureModel,
+  ): ValueSpecification {
+    const multiplicityOne = graph.getTypicalMultiplicity(
+      TYPICAL_MULTIPLICITY_TYPE.ONE,
+    );
+    const expression = new SimpleFunctionExpression(
+      extractElementNameFromPath(
+        QUERY_BUILDER_SUPPORTED_FUNCTIONS.JOIN_STRINGS,
+      ),
+      multiplicityOne,
+    );
+    const delimiter = new PrimitiveInstanceValue(
+      GenericTypeExplicitReference.create(
+        new GenericType(graph.getPrimitiveType(PRIMITIVE_TYPE.STRING)),
+      ),
+      multiplicityOne,
+    );
+    delimiter.values = [';'];
+    expression.parametersValues.push(
+      new VariableExpression(variableName, multiplicityOne),
+      delimiter,
+    );
+    return expression;
+  }
+
+  buildAggregateColumnState(
+    expression: SimpleFunctionExpression,
+    lambdaParam: VariableExpression,
+    projectionColumnState: QueryBuilderProjectionColumnState,
+  ): QueryBuilderAggregateColumnState | undefined {
+    if (
+      matchFunctionName(
+        expression.functionName,
+        QUERY_BUILDER_SUPPORTED_FUNCTIONS.JOIN_STRINGS,
+      )
+    ) {
+      const aggregateColumnState = new QueryBuilderAggregateColumnState(
+        projectionColumnState.projectionState.aggregationState,
+        projectionColumnState,
+        this,
+      );
+      aggregateColumnState.setLambdaParameterName(lambdaParam.name);
+
+      assertTrue(
+        expression.parametersValues.length === 2,
+        `Can't process joinStrings() expression: joinStrings() expects 1 argument`,
+      );
+
+      // variable
+      const variableExpression = guaranteeType(
+        expression.parametersValues[0],
+        VariableExpression,
+        `Can't process joinStrings() expression: only support joinStrings() immediately following a variable expression`,
+      );
+      assertTrue(
+        aggregateColumnState.lambdaParameterName === variableExpression.name,
+        `Can't process joinStrings() expression: expects variable used in lambda body '${variableExpression.name}' to match lambda parameter '${aggregateColumnState.lambdaParameterName}'`,
+      );
+
+      // delimiter
+      const delimiter = guaranteeType(
+        expression.parametersValues[1],
+        PrimitiveInstanceValue,
+        `Can't process joinStrings() expression: joinStrings() expects arugment #1 to be a primitive instance value`,
+      );
+      assertTrue(
+        delimiter.values.length === 1 && delimiter.values[0] === ';',
+        `Can't process joinStrings() expression: only support ';' as delimiter`,
+      );
+
+      // operator
+      assertTrue(
+        this.isCompatibleWithColumn(aggregateColumnState.projectionColumnState),
+        `Can't process joinStrings() expression: property is not compatible with operator`,
+      );
+      aggregateColumnState.setOperator(this);
+
+      return aggregateColumnState;
+    }
+
+    return undefined;
+  }
+
+  override getReturnType(
+    aggregateColumnState: QueryBuilderAggregateColumnState,
+  ): Type {
+    const graph =
+      aggregateColumnState.aggregationState.projectionState.queryBuilderState
+        .graphManagerState.graph;
+    return graph.getType(PRIMITIVE_TYPE.STRING);
+  }
+}

package/src/stores/fetch-structure/projection/aggregation/operators/QueryBuilderAggregateOperator_Max.ts

@@ -0,0 +1,174 @@
+/**
+ * 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 {
+  matchFunctionName,
+  PRIMITIVE_TYPE,
+  type ValueSpecification,
+  type SimpleFunctionExpression,
+  type VariableExpression,
+  type PureModel,
+  type AbstractPropertyExpression,
+} 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_Max extends QueryBuilderAggregateOperator {
+  getLabel(projectionColumnState: QueryBuilderProjectionColumnState): string {
+    return 'max';
+  }
+
+  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,
+          PRIMITIVE_TYPE.DATE,
+          PRIMITIVE_TYPE.STRICTDATE,
+          PRIMITIVE_TYPE.DATETIME,
+        ] as string[]
+      ).includes(propertyType.path);
+    }
+    return true;
+  }
+
+  buildAggregateExpression(
+    propertyExpression: AbstractPropertyExpression | undefined,
+    variableName: string,
+    graph: PureModel,
+  ): ValueSpecification {
+    return buildAggregateExpression(
+      (
+        [
+          PRIMITIVE_TYPE.DATE,
+          PRIMITIVE_TYPE.STRICTDATE,
+          PRIMITIVE_TYPE.DATETIME,
+        ] as string[]
+      ).includes(
+        propertyExpression?.func.genericType.value.rawType.path ??
+          PRIMITIVE_TYPE.NUMBER, // this decision does not affect the output expression
+      )
+        ? QUERY_BUILDER_SUPPORTED_FUNCTIONS.DATE_MAX
+        : QUERY_BUILDER_SUPPORTED_FUNCTIONS.MAX,
+      graph,
+      variableName,
+    );
+  }
+
+  buildAggregateColumnState(
+    expression: SimpleFunctionExpression,
+    lambdaParam: VariableExpression,
+    projectionColumnState: QueryBuilderProjectionColumnState,
+  ): QueryBuilderAggregateColumnState | undefined {
+    if (
+      projectionColumnState instanceof QueryBuilderSimpleProjectionColumnState
+    ) {
+      const propertyType =
+        projectionColumnState.propertyExpressionState.propertyExpression.func
+          .genericType.value.rawType;
+      switch (propertyType.path) {
+        case PRIMITIVE_TYPE.NUMBER:
+        case PRIMITIVE_TYPE.INTEGER:
+        case PRIMITIVE_TYPE.DECIMAL:
+        case PRIMITIVE_TYPE.FLOAT: {
+          if (
+            !matchFunctionName(
+              expression.functionName,
+              QUERY_BUILDER_SUPPORTED_FUNCTIONS.MAX,
+            )
+          ) {
+            return undefined;
+          }
+          return buildAggregateColumnState(
+            projectionColumnState,
+            lambdaParam,
+            expression,
+            QUERY_BUILDER_SUPPORTED_FUNCTIONS.MAX,
+            this,
+          );
+        }
+        case PRIMITIVE_TYPE.DATE:
+        case PRIMITIVE_TYPE.STRICTDATE:
+        case PRIMITIVE_TYPE.DATETIME: {
+          if (
+            !matchFunctionName(
+              expression.functionName,
+              QUERY_BUILDER_SUPPORTED_FUNCTIONS.DATE_MAX,
+            )
+          ) {
+            return undefined;
+          }
+          return buildAggregateColumnState(
+            projectionColumnState,
+            lambdaParam,
+            expression,
+            QUERY_BUILDER_SUPPORTED_FUNCTIONS.DATE_MAX,
+            this,
+          );
+        }
+        default:
+          return undefined;
+      }
+    }
+    if (
+      matchFunctionName(
+        expression.functionName,
+        QUERY_BUILDER_SUPPORTED_FUNCTIONS.MAX,
+      )
+    ) {
+      return buildAggregateColumnState(
+        projectionColumnState,
+        lambdaParam,
+        expression,
+        QUERY_BUILDER_SUPPORTED_FUNCTIONS.MAX,
+        this,
+      );
+    } else if (
+      matchFunctionName(
+        expression.functionName,
+        QUERY_BUILDER_SUPPORTED_FUNCTIONS.DATE_MAX,
+      )
+    ) {
+      return buildAggregateColumnState(
+        projectionColumnState,
+        lambdaParam,
+        expression,
+        QUERY_BUILDER_SUPPORTED_FUNCTIONS.DATE_MAX,
+        this,
+      );
+    }
+    return undefined;
+  }
+}