@finos/legend-query-builder 0.2.3 → 0.3.1

package/src/stores/fetch-structure/tds/olapGroupBy/QueryBuilderOlapGroupByState.ts

@@ -0,0 +1,377 @@
+/**
+ * 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, type Type } from '@finos/legend-graph';
+import {
+  addUniqueEntry,
+  deleteEntry,
+  guaranteeNonNullable,
+  hashArray,
+  uniq,
+  type Hashable,
+} from '@finos/legend-shared';
+import { action, makeObservable, observable } from 'mobx';
+import { QUERY_BUILDER_HASH_STRUCTURE } from '../../../../graphManager/QueryBuilderHashUtils.js';
+import { DEFAULT_LAMBDA_VARIABLE_NAME } from '../../../QueryBuilderConfig.js';
+import type { QueryBuilderProjectionColumnDragSource } from '../projection/QueryBuilderProjectionColumnState.js';
+import { QueryBuilderTDSColumnState } from '../QueryBuilderTDSColumnState_.js';
+import type { QueryBuilderTDSState } from '../QueryBuilderTDSState.js';
+import type { COLUMN_SORT_TYPE } from '../QueryResultSetModifierState.js';
+import type { QueryBuilderTDSOlapOperator } from './operators/QueryBuilderTDSOlapOperator_.js';
+
+export const QUERY_BUILDER_OLAP_COLUMN_DND_TYPE = 'OLAP_COLUMN';
+
+export interface QueryBuilderOlapColumnDragSource {
+  columnState: QueryBuilderOlapGroupByColumnState;
+}
+
+export type QueryBuilderOlapDropTarget =
+  | QueryBuilderProjectionColumnDragSource
+  | QueryBuilderOlapColumnDragSource;
+
+export class OlapGroupByColumnSortByState implements Hashable {
+  columnState: QueryBuilderTDSColumnState;
+  sortType: COLUMN_SORT_TYPE;
+
+  constructor(
+    columnState: QueryBuilderTDSColumnState,
+    sortType: COLUMN_SORT_TYPE,
+  ) {
+    makeObservable(this, {
+      columnState: observable,
+      sortType: observable,
+      setColumnState: action,
+      setSortType: action,
+    });
+
+    this.columnState = columnState;
+    this.sortType = sortType;
+  }
+
+  setColumnState(colState: QueryBuilderTDSColumnState): void {
+    this.columnState = colState;
+  }
+
+  setSortType(type: COLUMN_SORT_TYPE): void {
+    this.sortType = type;
+  }
+
+  get hashCode(): string {
+    return hashArray([
+      QUERY_BUILDER_HASH_STRUCTURE.OLAP_GROUPBY_COLUMN_SORTBY_STATE,
+      this.sortType,
+      this.columnState.columnName,
+    ]);
+  }
+}
+
+export abstract class QueryBuilderTDSOlapOperatorState implements Hashable {
+  readonly olapState: QueryBuilderOlapGroupByState;
+  lambdaParameterName: string = DEFAULT_LAMBDA_VARIABLE_NAME;
+  operator: QueryBuilderTDSOlapOperator;
+
+  constructor(
+    olapState: QueryBuilderOlapGroupByState,
+    operator: QueryBuilderTDSOlapOperator,
+  ) {
+    this.olapState = olapState;
+    this.operator = operator;
+  }
+
+  setLambdaParameterName(paramName: string): void {
+    this.lambdaParameterName = paramName;
+  }
+
+  setOperator(val: QueryBuilderTDSOlapOperator): void {
+    this.operator = val;
+  }
+
+  get hashCode(): string {
+    return hashArray([
+      QUERY_BUILDER_HASH_STRUCTURE.OLAP_GROUPBY_OPERATION_STATE,
+      this.lambdaParameterName,
+      this.operator,
+    ]);
+  }
+}
+
+export class QueryBuilderTDSOlapRankOperatorState extends QueryBuilderTDSOlapOperatorState {
+  constructor(
+    olapState: QueryBuilderOlapGroupByState,
+    operator: QueryBuilderTDSOlapOperator,
+  ) {
+    super(olapState, operator);
+    makeObservable(this, {
+      setLambdaParameterName: action,
+    });
+  }
+}
+
+export class QueryBuilderTDSOlapAggreationOperatorState extends QueryBuilderTDSOlapOperatorState {
+  columnState: QueryBuilderTDSColumnState;
+  constructor(
+    olapState: QueryBuilderOlapGroupByState,
+    operator: QueryBuilderTDSOlapOperator,
+    columnState: QueryBuilderTDSColumnState,
+  ) {
+    super(olapState, operator);
+    makeObservable(this, {
+      columnState: observable,
+      setColumnState: action,
+      setLambdaParameterName: action,
+    });
+    this.columnState = columnState;
+  }
+
+  setColumnState(val: QueryBuilderTDSColumnState): void {
+    this.columnState = val;
+  }
+
+  override get hashCode(): string {
+    return hashArray([
+      QUERY_BUILDER_HASH_STRUCTURE.OLAP_GROUPBY_AGG_OPERATION_STATE,
+      this.lambdaParameterName,
+      this.operator,
+      this.columnState.columnName,
+    ]);
+  }
+}
+
+export class QueryBuilderOlapGroupByColumnState
+  extends QueryBuilderTDSColumnState
+  implements Hashable
+{
+  readonly olapState: QueryBuilderOlapGroupByState;
+  windowColumns: QueryBuilderTDSColumnState[] = [];
+  sortByState: OlapGroupByColumnSortByState | undefined;
+  operationState: QueryBuilderTDSOlapOperatorState;
+  columnName: string;
+
+  constructor(
+    olapState: QueryBuilderOlapGroupByState,
+    windowColumns: QueryBuilderTDSColumnState[],
+    sortType: OlapGroupByColumnSortByState | undefined,
+    operationState: QueryBuilderTDSOlapOperatorState,
+    columnName: string,
+  ) {
+    super();
+    makeObservable(this, {
+      windowColumns: observable,
+      sortByState: observable,
+      operationState: observable,
+      columnName: observable,
+      setOperatorState: observable,
+      setColumnName: action,
+      setSortBy: action,
+      changeWindow: action,
+      deleteWindow: action,
+      addWindow: action,
+      changeOperator: action,
+      changeSortBy: action,
+    });
+    this.olapState = olapState;
+    this.windowColumns = windowColumns;
+    this.sortByState = sortType;
+    this.operationState = operationState;
+    this.columnName = columnName;
+  }
+
+  get columnOlapGroupIdx(): number {
+    return this.olapState.olapColumns.findIndex((e) => e === this);
+  }
+
+  get possibleReferencedColumns(): QueryBuilderTDSColumnState[] {
+    // column can only reference TDS columns already defined, i.e in an earlier index of the olap columns
+    const idx = this.olapState.tdsState.tdsColumns.findIndex((e) => e === this);
+    if (idx === -1) {
+      return this.olapState.tdsState.tdsColumns;
+    }
+    return this.olapState.tdsState.tdsColumns.slice(0, idx);
+  }
+
+  get referencedTDSColumns(): QueryBuilderTDSColumnState[] {
+    const operatorReference =
+      this.operationState instanceof QueryBuilderTDSOlapAggreationOperatorState
+        ? [this.operationState.columnState]
+        : [];
+    const soryByReference = this.sortByState
+      ? [this.sortByState.columnState]
+      : [];
+    return [...this.windowColumns, ...soryByReference, ...operatorReference];
+  }
+
+  getColumnType(): Type | undefined {
+    return this.operationState.operator.getOperatorReturnType(
+      this.olapState.tdsState.queryBuilderState.graphManagerState.graph,
+    );
+  }
+
+  setColumnName(val: string): void {
+    this.columnName = val;
+  }
+
+  setOperatorState(op: QueryBuilderTDSOlapOperatorState): void {
+    this.operationState = op;
+  }
+
+  setSortBy(val: OlapGroupByColumnSortByState | undefined): void {
+    this.sortByState = val;
+  }
+
+  changeWindow(val: QueryBuilderTDSColumnState, idx: number): void {
+    this.windowColumns[idx] = val;
+  }
+
+  addWindow(val: QueryBuilderTDSColumnState): void {
+    addUniqueEntry(this.windowColumns, val);
+  }
+
+  deleteWindow(val: QueryBuilderTDSColumnState): void {
+    deleteEntry(this.windowColumns, val);
+  }
+
+  possibleAggregatedColumns(
+    op: QueryBuilderTDSOlapOperator,
+  ): QueryBuilderTDSColumnState[] {
+    if (op.isColumnAggregator()) {
+      return this.possibleReferencedColumns.filter((col) =>
+        op.isCompatibleWithColumn(col),
+      );
+    }
+    return [];
+  }
+
+  changeOperator(olapOp: QueryBuilderTDSOlapOperator): void {
+    const currentOperator = this.operationState.operator;
+    const currentAggregateColumn =
+      this.operationState instanceof QueryBuilderTDSOlapAggreationOperatorState
+        ? this.operationState.columnState
+        : undefined;
+    if (currentOperator !== olapOp) {
+      if (olapOp.isColumnAggregator()) {
+        const compatibleAggCol =
+          currentAggregateColumn &&
+          olapOp.isCompatibleWithColumn(currentAggregateColumn)
+            ? currentAggregateColumn
+            : this.possibleAggregatedColumns(olapOp)[0];
+        if (compatibleAggCol) {
+          this.setOperatorState(
+            new QueryBuilderTDSOlapAggreationOperatorState(
+              this.olapState,
+              olapOp,
+              compatibleAggCol,
+            ),
+          );
+        }
+      } else {
+        this.setOperatorState(
+          new QueryBuilderTDSOlapRankOperatorState(this.olapState, olapOp),
+        );
+      }
+    }
+  }
+
+  changeSortBy(sortOp: COLUMN_SORT_TYPE | undefined): void {
+    const sortByState = this.sortByState;
+    if (sortByState?.sortType !== sortOp) {
+      if (sortOp) {
+        const sortInfoOpState =
+          sortByState ??
+          new OlapGroupByColumnSortByState(
+            guaranteeNonNullable(this.possibleReferencedColumns[0]),
+            sortOp,
+          );
+        sortInfoOpState.setSortType(sortOp);
+        this.setSortBy(sortInfoOpState);
+      } else {
+        this.setSortBy(undefined);
+      }
+    }
+  }
+
+  get hashCode(): string {
+    return hashArray([
+      QUERY_BUILDER_HASH_STRUCTURE.OLAP_GROUPBY_COLUMN_STATE,
+      hashArray(this.windowColumns),
+      this.sortByState ?? '',
+      this.operationState,
+      this.columnName,
+    ]);
+  }
+}
+
+export class QueryBuilderOlapGroupByState implements Hashable {
+  readonly tdsState: QueryBuilderTDSState;
+  olapColumns: QueryBuilderOlapGroupByColumnState[] = [];
+  operators: QueryBuilderTDSOlapOperator[];
+  editColumn: QueryBuilderOlapGroupByColumnState | undefined;
+
+  constructor(
+    tdsState: QueryBuilderTDSState,
+    operators: QueryBuilderTDSOlapOperator[],
+  ) {
+    makeObservable(this, {
+      olapColumns: observable,
+      editColumn: observable,
+      addOlapColumn: action,
+      removeColumn: action,
+      moveColumn: action,
+      setEditColumn: action,
+    });
+    this.tdsState = tdsState;
+    this.operators = operators;
+  }
+
+  get isEmpty(): boolean {
+    return !this.olapColumns.length;
+  }
+
+  get referencedTDSColumns(): QueryBuilderTDSColumnState[] {
+    return uniq(this.olapColumns.map((c) => c.referencedTDSColumns).flat());
+  }
+
+  setEditColumn(col: QueryBuilderOlapGroupByColumnState | undefined): void {
+    this.editColumn = col;
+  }
+
+  findOperator(func: string): QueryBuilderTDSOlapOperator | undefined {
+    return this.operators.find((o) => matchFunctionName(func, o.pureFunc));
+  }
+
+  addOlapColumn(olapGroupByCol: QueryBuilderOlapGroupByColumnState): void {
+    addUniqueEntry(this.olapColumns, olapGroupByCol);
+  }
+
+  removeColumn(column: QueryBuilderOlapGroupByColumnState): void {
+    deleteEntry(this.olapColumns, column);
+  }
+
+  moveColumn(fromIndex: number, toIndex: number): void {
+    const fromCol = this.olapColumns[fromIndex];
+    const toCol = this.olapColumns[toIndex];
+    if (fromCol && toCol) {
+      this.olapColumns[fromIndex] = toCol;
+      this.olapColumns[toIndex] = fromCol;
+    }
+  }
+
+  get hashCode(): string {
+    return hashArray([
+      QUERY_BUILDER_HASH_STRUCTURE.OLAP_GROUPBY_STATE,
+      hashArray(this.olapColumns),
+    ]);
+  }
+}

package/src/stores/fetch-structure/tds/olapGroupBy/QueryBuilderOlapGroupByStateBuilder.ts

@@ -0,0 +1,237 @@
+/**
+ * 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,
+  LambdaFunction,
+  LambdaFunctionInstanceValue,
+  matchFunctionName,
+  PrimitiveInstanceValue,
+  SimpleFunctionExpression,
+  VariableExpression,
+} from '@finos/legend-graph';
+import {
+  assertTrue,
+  assertType,
+  guaranteeIsString,
+  guaranteeNonNullable,
+  guaranteeType,
+} 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 {
+  getTDSColumnState,
+  getTDSColSortTypeFromFunctionName,
+} from '../QueryBuilderTDSHelper.js';
+import { QueryBuilderTDSState } from '../QueryBuilderTDSState.js';
+import {
+  type QueryBuilderTDSOlapOperatorState,
+  OlapGroupByColumnSortByState,
+  QueryBuilderOlapGroupByColumnState,
+  QueryBuilderTDSOlapAggreationOperatorState,
+  QueryBuilderTDSOlapRankOperatorState,
+} from './QueryBuilderOlapGroupByState.js';
+
+export const processTDSOlapGroupByExpression = (
+  expression: SimpleFunctionExpression,
+  queryBuilderState: QueryBuilderState,
+): void => {
+  // check parameters
+  const parametersLength = expression.parametersValues.length;
+  assertTrue(
+    parametersLength === 4 || parametersLength === 5,
+    `Can't process sort() expression: olapGroupBy() expects 3 or 4 argument`,
+  );
+
+  // expected expressions
+  const containsSortByExpression = parametersLength === 5;
+  const windowColumnsExpression = expression.parametersValues[1];
+  const sortByValueSpec = containsSortByExpression
+    ? expression.parametersValues[2]
+    : undefined;
+  const olapOperationExpression = containsSortByExpression
+    ? expression.parametersValues[3]
+    : expression.parametersValues[2];
+  const olapColumnExpression = containsSortByExpression
+    ? expression.parametersValues[4]
+    : expression.parametersValues[3];
+
+  // check preceding expression
+  const precedingExpression = guaranteeType(
+    expression.parametersValues[0],
+    SimpleFunctionExpression,
+    `Can't process olapGroupBy() expression: only support olapGroupBy() immediately following an expression`,
+  );
+  assertTrue(
+    matchFunctionName(precedingExpression.functionName, [
+      QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_TAKE,
+      QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_DISTINCT,
+      QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_SORT,
+      QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_PROJECT,
+      QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_GROUP_BY,
+      QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_FILTER,
+      QUERY_BUILDER_SUPPORTED_FUNCTIONS.OLAP_GROUPBY,
+    ]),
+    `Can't process olapGroupBy() expression: only support olapGroupBy() in TDS expression`,
+  );
+  QueryBuilderValueSpecificationProcessor.process(
+    precedingExpression,
+    queryBuilderState,
+  );
+
+  // process window columns
+  const tdsState = guaranteeType(
+    queryBuilderState.fetchStructureState.implementation,
+    QueryBuilderTDSState,
+  );
+  assertType(
+    windowColumnsExpression,
+    CollectionInstanceValue,
+    `Can't process olapGroupBy() expression: olapGroupBy() expects argument #1 to be a collection`,
+  );
+  const windowColumns = windowColumnsExpression.values.map((value) => {
+    const columnName = guaranteeIsString(
+      guaranteeType(
+        value,
+        PrimitiveInstanceValue,
+        'Can`t process OLAP window column expression: Column should be a primitive instance value',
+      ).values[0],
+      'Can`t process OLAP window column expression: Column should be a string primitive instance value',
+    );
+    return getTDSColumnState(tdsState, columnName);
+  });
+
+  // process sortBy
+  let sortByState: OlapGroupByColumnSortByState | undefined;
+  if (containsSortByExpression) {
+    const sortByExpression = guaranteeType(
+      sortByValueSpec,
+      SimpleFunctionExpression,
+      `Can't process olapGroupBy sortBy expression: only support function expression of 'asc' or 'desc'`,
+    );
+    const sortByFunctionName = sortByExpression.functionName;
+    const colSortType = getTDSColSortTypeFromFunctionName(sortByFunctionName);
+    const colSortVal = guaranteeIsString(
+      guaranteeType(
+        sortByExpression.parametersValues[0],
+        PrimitiveInstanceValue,
+        'Can`t process OLAP sort column : OLAP sort column should be a primitive instance value',
+      ).values[0],
+      'Can`t process OLAP sort column: OLAP sort column should be a string primitive instance value',
+    );
+    const sortColState = getTDSColumnState(tdsState, colSortVal);
+    sortByState = new OlapGroupByColumnSortByState(sortColState, colSortType);
+  }
+  // process olap operation
+  let operatorState: QueryBuilderTDSOlapOperatorState;
+  if (olapOperationExpression instanceof SimpleFunctionExpression) {
+    assertTrue(
+      matchFunctionName(olapOperationExpression.functionName, [
+        QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_FUNC,
+      ]),
+      `Can't process olapGroupBy() operation expression: olapGroupBy() aggregation should contain function 'func'`,
+    );
+    const olapOperationExpressionParams =
+      olapOperationExpression.parametersValues;
+    const columnName = guaranteeIsString(
+      guaranteeType(
+        olapOperationExpressionParams[0],
+        PrimitiveInstanceValue,
+        'Can`t process OLAP opperation expression: Function `func` first parameter should be a primitive instance value',
+      ).values[0],
+      'Can`t process OLAP opperation expression: Function `func` first parameter should be a string primitive instance value',
+    );
+    const oppColumnState = getTDSColumnState(tdsState, columnName);
+    const operationLambda = guaranteeType(
+      guaranteeType(
+        olapOperationExpressionParams[1],
+        LambdaFunctionInstanceValue,
+      ).values[0],
+      LambdaFunction,
+    );
+    assertTrue(operationLambda.expressionSequence.length === 1);
+    const operationFunctionExp = guaranteeType(
+      operationLambda.expressionSequence[0],
+      SimpleFunctionExpression,
+    );
+    const operation = guaranteeNonNullable(
+      tdsState.olapGroupByState.findOperator(operationFunctionExp.functionName),
+      `olapGroupBy() operator '${operationFunctionExp.functionName}' not supported`,
+    );
+    operatorState = new QueryBuilderTDSOlapAggreationOperatorState(
+      tdsState.olapGroupByState,
+      operation,
+      oppColumnState,
+    );
+    operatorState.setLambdaParameterName(
+      guaranteeType(
+        operationLambda.functionType.parameters[0],
+        VariableExpression,
+        `Can't process olapGroupBy() operation lambda: only support olapGroupBy() operation lambda with 1 parameter of type 'VariableExpression'`,
+      ).name,
+    );
+  } else {
+    const operationLambda = guaranteeType(
+      guaranteeType(olapOperationExpression, LambdaFunctionInstanceValue)
+        .values[0],
+      LambdaFunction,
+    );
+    assertTrue(operationLambda.expressionSequence.length === 1);
+    const operationFunctionExp = guaranteeType(
+      operationLambda.expressionSequence[0],
+      SimpleFunctionExpression,
+    );
+    const operation = guaranteeNonNullable(
+      tdsState.olapGroupByState.findOperator(operationFunctionExp.functionName),
+      `olapGroupBy() operator '${operationFunctionExp.functionName}' not supported`,
+    );
+    assertTrue(
+      !operation.isColumnAggregator(),
+      `Operator '${operation.getLabel()}' expects a TDS column to aggregate against`,
+    );
+    operatorState = new QueryBuilderTDSOlapRankOperatorState(
+      tdsState.olapGroupByState,
+      operation,
+    );
+    operatorState.setLambdaParameterName(
+      guaranteeType(
+        operationLambda.functionType.parameters[0],
+        VariableExpression,
+        `Can't process olapGroupBy() operation lambda: only support olapGroupBy() operation lambda with 1 parameter of type 'VariableExpression'`,
+      ).name,
+    );
+  }
+
+  // main col
+  const olapColumnValue = guaranteeIsString(
+    guaranteeType(
+      olapColumnExpression,
+      PrimitiveInstanceValue,
+      'Can`t process OLAP column: OLAP column should be a primitive instance value',
+    ).values[0],
+    'Can`t process OLAP column: OLAP column should be a string primitive instance value',
+  );
+  const olapGroupByColumnState = new QueryBuilderOlapGroupByColumnState(
+    tdsState.olapGroupByState,
+    windowColumns,
+    sortByState,
+    operatorState,
+    olapColumnValue,
+  );
+  tdsState.olapGroupByState.addOlapColumn(olapGroupByColumnState);
+  tdsState.setShowOlapGroupByPanel(true);
+};