@finos/legend-application-query 5.2.6 → 6.0.0

package/src/stores/query-builder/QueryBuilderMilestoningState.ts

@@ -0,0 +1,164 @@
+/**
+ * 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 { LambdaParameterState } from '@finos/legend-application';
+import {
+  DEFAULT_BUSINESS_DATE_MILESTONING_PARAMETER_NAME,
+  DEFAULT_PROCESSING_DATE_MILESTONING_PARAMETER_NAME,
+  GenericType,
+  GenericTypeExplicitReference,
+  getMilestoneTemporalStereotype,
+  MILESTONING_STEREOTYPE,
+  observe_ValueSpecification,
+  PRIMITIVE_TYPE,
+  TYPICAL_MULTIPLICITY_TYPE,
+  VariableExpression,
+  type ValueSpecification,
+} from '@finos/legend-graph';
+import { action, computed, makeObservable, observable } from 'mobx';
+import type { QueryBuilderState } from './QueryBuilderState.js';
+
+export class QueryBuilderMilestoningState {
+  queryBuilderState: QueryBuilderState;
+
+  showMilestoningEditor = false;
+  // TODO: Change this when we modify how we deal with milestoning.
+  // See https://github.com/finos/legend-studio/issues/1149
+  businessDate?: ValueSpecification | undefined;
+  processingDate?: ValueSpecification | undefined;
+
+  constructor(queryBuilderState: QueryBuilderState) {
+    makeObservable(this, {
+      processingDate: observable,
+      businessDate: observable,
+      showMilestoningEditor: observable,
+      isMilestonedQuery: computed,
+      setProcessingDate: action,
+      setBusinessDate: action,
+      setShowMilestoningEditor: action,
+    });
+
+    this.queryBuilderState = queryBuilderState;
+  }
+
+  get isMilestonedQuery(): boolean {
+    return Boolean(this.businessDate ?? this.processingDate);
+  }
+
+  setShowMilestoningEditor(val: boolean): void {
+    this.showMilestoningEditor = val;
+  }
+
+  private initializeQueryMilestoningParameters(stereotype: string): void {
+    switch (stereotype) {
+      case MILESTONING_STEREOTYPE.BUSINESS_TEMPORAL: {
+        this.setBusinessDate(
+          this.buildMilestoningParameter(
+            DEFAULT_BUSINESS_DATE_MILESTONING_PARAMETER_NAME,
+          ),
+        );
+        break;
+      }
+      case MILESTONING_STEREOTYPE.PROCESSING_TEMPORAL: {
+        this.setProcessingDate(
+          this.buildMilestoningParameter(
+            DEFAULT_PROCESSING_DATE_MILESTONING_PARAMETER_NAME,
+          ),
+        );
+        break;
+      }
+      case MILESTONING_STEREOTYPE.BITEMPORAL: {
+        this.setProcessingDate(
+          this.buildMilestoningParameter(
+            DEFAULT_PROCESSING_DATE_MILESTONING_PARAMETER_NAME,
+          ),
+        );
+        this.setBusinessDate(
+          this.buildMilestoningParameter(
+            DEFAULT_BUSINESS_DATE_MILESTONING_PARAMETER_NAME,
+          ),
+        );
+        break;
+      }
+      default:
+    }
+  }
+
+  setProcessingDate(val: ValueSpecification | undefined): void {
+    this.processingDate = val
+      ? observe_ValueSpecification(
+          val,
+          this.queryBuilderState.observableContext,
+        )
+      : val;
+  }
+
+  setBusinessDate(val: ValueSpecification | undefined): void {
+    this.businessDate = val
+      ? observe_ValueSpecification(
+          val,
+          this.queryBuilderState.observableContext,
+        )
+      : val;
+  }
+
+  updateMilestoningConfiguration(): void {
+    const currentclass = this.queryBuilderState.class;
+    if (currentclass !== undefined) {
+      const stereotype = getMilestoneTemporalStereotype(
+        currentclass,
+        this.queryBuilderState.graphManagerState.graph,
+      );
+      this.setBusinessDate(undefined);
+      this.setProcessingDate(undefined);
+      if (stereotype) {
+        this.initializeQueryMilestoningParameters(stereotype);
+        // Show the parameter panel because we populate paramaters state with milestoning parameters
+        this.queryBuilderState.setShowParametersPanel(true);
+      }
+    }
+  }
+
+  buildMilestoningParameter(parameterName: string): ValueSpecification {
+    const milestoningParameter = new VariableExpression(
+      parameterName,
+      this.queryBuilderState.graphManagerState.graph.getTypicalMultiplicity(
+        TYPICAL_MULTIPLICITY_TYPE.ONE,
+      ),
+      GenericTypeExplicitReference.create(
+        new GenericType(
+          this.queryBuilderState.parametersState.queryBuilderState.graphManagerState.graph.getPrimitiveType(
+            PRIMITIVE_TYPE.DATE,
+          ),
+        ),
+      ),
+    );
+    if (
+      !this.queryBuilderState.parametersState.parameterStates.find(
+        (p) => p.variableName === parameterName,
+      )
+    ) {
+      const variableState = new LambdaParameterState(
+        milestoningParameter,
+        this.queryBuilderState.observableContext,
+        this.queryBuilderState.graphManagerState.graph,
+      );
+      variableState.mockParameterValue();
+      this.queryBuilderState.parametersState.addParameter(variableState);
+    }
+    return milestoningParameter;
+  }
+}

package/src/stores/query-builder/QueryBuilderParametersState.ts

@@ -0,0 +1,52 @@
+/**
+ * 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 {
+  LambdaParametersState,
+  type LambdaParameterState,
+} from '@finos/legend-application';
+import { observable, makeObservable, action } from 'mobx';
+import type { QueryBuilderState } from './QueryBuilderState.js';
+
+export const QUERY_BUILDER_PARAMETER_DND_TYPE = 'PARAMETER';
+
+export interface QueryBuilderParameterDragSource {
+  variable: LambdaParameterState;
+}
+
+export class QueryBuilderParametersState extends LambdaParametersState {
+  selectedParameter: LambdaParameterState | undefined;
+  queryBuilderState: QueryBuilderState;
+
+  constructor(queryBuilderState: QueryBuilderState) {
+    super();
+    makeObservable(this, {
+      parameterValuesEditorState: observable,
+      parameterStates: observable,
+      addParameter: action,
+      removeParameter: action,
+      setParameters: action,
+      selectedParameter: observable,
+      setSelectedParameter: action,
+    });
+
+    this.queryBuilderState = queryBuilderState;
+  }
+
+  setSelectedParameter(val: LambdaParameterState | undefined): void {
+    this.selectedParameter = val;
+  }
+}

package/src/stores/query-builder/QueryBuilderPreviewDataHelper.ts

@@ -0,0 +1,202 @@
+/**
+ * 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 {
+  RawLambda,
+  AbstractPropertyExpression,
+} from '@finos/legend-graph';
+import { guaranteeNonNullable, guaranteeType } from '@finos/legend-shared';
+import { QueryBuilderAggregateOperator_Average } from './fetch-structure/projection/aggregation/operators/QueryBuilderAggregateOperator_Average.js';
+import { QueryBuilderAggregateOperator_Count } from './fetch-structure/projection/aggregation/operators/QueryBuilderAggregateOperator_Count.js';
+import { QueryBuilderAggregateOperator_DistinctCount } from './fetch-structure/projection/aggregation/operators/QueryBuilderAggregateOperator_DistinctCount.js';
+import { QueryBuilderAggregateOperator_Max } from './fetch-structure/projection/aggregation/operators/QueryBuilderAggregateOperator_Max.js';
+import { QueryBuilderAggregateOperator_Min } from './fetch-structure/projection/aggregation/operators/QueryBuilderAggregateOperator_Min.js';
+import { QueryBuilderAggregateOperator_StdDev_Population } from './fetch-structure/projection/aggregation/operators/QueryBuilderAggregateOperator_StdDev_Population.js';
+import { QueryBuilderAggregateOperator_StdDev_Sample } from './fetch-structure/projection/aggregation/operators/QueryBuilderAggregateOperator_StdDev_Sample.js';
+import { QueryBuilderAggregateOperator_Sum } from './fetch-structure/projection/aggregation/operators/QueryBuilderAggregateOperator_Sum.js';
+import { QueryBuilderSimpleProjectionColumnState } from './fetch-structure/projection/QueryBuilderProjectionColumnState.js';
+import type { QueryBuilderState } from './QueryBuilderState.js';
+import {
+  COLUMN_SORT_TYPE,
+  SortColumnState,
+} from './fetch-structure/projection/QueryResultSetModifierState.js';
+import type { QueryBuilderAggregateOperator } from './fetch-structure/projection/aggregation/QueryBuilderAggregateOperator.js';
+import { QueryBuilderProjectionState } from './fetch-structure/projection/QueryBuilderProjectionState.js';
+
+const PREVIEW_DATA_TAKE_LIMIT = 10;
+const PREVIEW_DATA_NON_NUMERIC_VALUE_COLUMN_NAME = 'Value';
+const PREVIEW_DATA_NON_NUMERIC_COUNT_COLUMN_NAME = 'Count';
+
+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 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,
+  ],
+];
+
+const createSimpleProjectionColumn = (
+  projectionState: QueryBuilderProjectionState,
+  propertyExpression: AbstractPropertyExpression,
+  columnName: string,
+): QueryBuilderSimpleProjectionColumnState => {
+  const col = new QueryBuilderSimpleProjectionColumnState(
+    projectionState,
+    propertyExpression,
+    false,
+  );
+  col.setColumnName(columnName);
+  return col;
+};
+
+export type QueryBuilderPreviewData = {
+  columns: string[];
+  rows: { values: (string | number)[] }[];
+};
+
+export const buildNumericPreviewDataQuery = (
+  queryBuilderState: QueryBuilderState,
+  propertyExpression: AbstractPropertyExpression,
+): RawLambda => {
+  // Build the following query
+  //
+  // ClassX.all()->groupBy(
+  //   [],
+  //   [
+  //     agg(x|$x.prop, x|$x->count()),
+  //     agg(x|$x.prop, x|$x->distinct()->count()),
+  //     agg(x|$x.prop, x|$x->sum()),
+  //     agg(x|$x.prop, x|$x->min()),
+  //     agg(x|$x.prop, x|$x->max()),
+  //     agg(x|$x.prop, x|$x->average()),
+  //     agg(x|$x.prop, x|$x->stdDevPopulation()),
+  //     agg(x|$x.prop, x|$x->stdDevSample())
+  //   ],
+  //   [
+  //     'Count',
+  //     'Distinct Count',
+  //     'Sum',
+  //     'Min',
+  //     'Max',
+  //     'Average',
+  //     'Std Dev (Population)',
+  //     'Std Dev (Sample)'
+  //   ]
+  // )
+  const builderState = queryBuilderState.INTERNAL__toBasicQueryBuilderState();
+  const projectionState = guaranteeType(
+    builderState.fetchStructureState.implementation,
+    QueryBuilderProjectionState,
+  );
+  const aggregationState = projectionState.aggregationState;
+  NUMERIC_AGG_FUNC_TO_AGG_OP.forEach((val) => {
+    const colState = createSimpleProjectionColumn(
+      projectionState,
+      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,
+): RawLambda => {
+  // Build the following query
+  //
+  // ClassX.all()->groupBy(
+  //   [
+  //     x|$x.prop
+  //   ],
+  //   [
+  //     agg(x|$x.prop, x|$x->count())
+  //   ],
+  //   [
+  //     'Value',
+  //     'Count'
+  //   ]
+  // )->sort([desc('Count'), asc('Value')])->take(10)
+  const builderState = queryBuilderState.INTERNAL__toBasicQueryBuilderState();
+  const projectionState = guaranteeType(
+    builderState.fetchStructureState.implementation,
+    QueryBuilderProjectionState,
+  );
+  const valueProjectionColState = createSimpleProjectionColumn(
+    projectionState,
+    propertyExpression,
+    PREVIEW_DATA_NON_NUMERIC_VALUE_COLUMN_NAME,
+  );
+  const valueCountProjectionState = createSimpleProjectionColumn(
+    projectionState,
+    propertyExpression,
+    PREVIEW_DATA_NON_NUMERIC_COUNT_COLUMN_NAME,
+  );
+  projectionState.columns = [
+    valueProjectionColState,
+    valueCountProjectionState,
+  ];
+  const distinctCountOp = guaranteeNonNullable(
+    projectionState.aggregationState.operators.find(
+      (t) => t instanceof QueryBuilderAggregateOperator_Count,
+    ),
+  );
+  projectionState.aggregationState.changeColumnAggregateOperator(
+    distinctCountOp,
+    valueCountProjectionState,
+  );
+  // result set
+  projectionState.resultSetModifierState.limit = PREVIEW_DATA_TAKE_LIMIT;
+  const sortValueCount = new SortColumnState(valueCountProjectionState);
+  sortValueCount.sortType = COLUMN_SORT_TYPE.DESC;
+  projectionState.resultSetModifierState.sortColumns = [
+    sortValueCount,
+    new SortColumnState(valueProjectionColState),
+  ];
+  return builderState.resultState.buildExecutionRawLambda();
+};