@finos/legend-query-builder 4.0.9 → 4.0.10

package/src/stores/QueryBuilderResultState.ts

@@ -37,6 +37,7 @@ import {
   buildRawLambdaFromLambdaFunction,
   reportGraphAnalytics,
   extractExecutionResultValues,
+  TDSExecutionResult,
 } from '@finos/legend-graph';
 import { buildLambdaFunction } from './QueryBuilderValueSpecificationBuilder.js';
 import { DEFAULT_TAB_SIZE } from '@finos/legend-application';
@@ -56,6 +57,17 @@ export interface ExportDataInfo {
   serializationFormat?: EXECUTION_SERIALIZATION_FORMAT | undefined;
 }
 
+export interface QueryBuilderTDSResultCellData {
+  value: string | number | boolean | null | undefined;
+  columnName: string;
+  coordinates: QueryBuilderTDSResultCellCoordinate;
+}
+
+export interface QueryBuilderTDSResultCellCoordinate {
+  rowIndex: number;
+  colIndex: number;
+}
+
 export class QueryBuilderResultState {
   readonly queryBuilderState: QueryBuilderState;
   readonly exportDataState = ActionState.create();
@@ -70,6 +82,10 @@ export class QueryBuilderResultState {
   latestRunHashCode?: string | undefined;
   queryRunPromise: Promise<ExecutionResult> | undefined = undefined;
 
+  selectedCells: QueryBuilderTDSResultCellData[];
+  mousedOverCell: QueryBuilderTDSResultCellData | null = null;
+  isSelectingCells: boolean;
+
   constructor(queryBuilderState: QueryBuilderState) {
     makeObservable(this, {
       executionResult: observable,
@@ -78,18 +94,28 @@ export class QueryBuilderResultState {
       latestRunHashCode: observable,
       queryRunPromise: observable,
       isGeneratingPlan: observable,
+      selectedCells: observable,
+      mousedOverCell: observable,
       isRunningQuery: observable,
+      isSelectingCells: observable,
+      setIsSelectingCells: action,
       setIsRunningQuery: action,
       setExecutionResult: action,
       setExecutionDuration: action,
       setPreviewLimit: action,
+      addCellData: action,
+      setSelectedCells: action,
+      setMouseOverCell: action,
       setQueryRunPromise: action,
+
       exportData: flow,
       runQuery: flow,
       cancelQuery: flow,
       generatePlan: flow,
     });
+    this.isSelectingCells = false;
 
+    this.selectedCells = [];
     this.queryBuilderState = queryBuilderState;
     this.executionPlanState = new ExecutionPlanState(
       this.queryBuilderState.applicationStore,
@@ -97,6 +123,10 @@ export class QueryBuilderResultState {
     );
   }
 
+  setIsSelectingCells = (val: boolean): void => {
+    this.isSelectingCells = val;
+  };
+
   setIsRunningQuery = (val: boolean): void => {
     this.isRunningQuery = val;
   };
@@ -113,12 +143,64 @@ export class QueryBuilderResultState {
     this.previewLimit = Math.max(1, val);
   };
 
+  addCellData = (val: QueryBuilderTDSResultCellData): void => {
+    this.selectedCells.push(val);
+  };
+
+  setSelectedCells = (val: QueryBuilderTDSResultCellData[]): void => {
+    this.selectedCells = val;
+  };
+
+  setMouseOverCell = (val: QueryBuilderTDSResultCellData | null): void => {
+    this.mousedOverCell = val;
+  };
+
   setQueryRunPromise = (
     promise: Promise<ExecutionResult> | undefined,
   ): void => {
     this.queryRunPromise = promise;
   };
 
+  findColumnFromCoordinates = (
+    colIndex: number,
+  ): string | number | boolean | null | undefined => {
+    if (
+      !this.executionResult ||
+      !(this.executionResult instanceof TDSExecutionResult)
+    ) {
+      return undefined;
+    }
+    return this.executionResult.result.columns[colIndex];
+  };
+
+  findRowFromRowIndex = (
+    rowIndex: number,
+  ): (string | number | boolean | null)[] => {
+    if (
+      !this.executionResult ||
+      !(this.executionResult instanceof TDSExecutionResult)
+    ) {
+      return [''];
+    }
+    return this.executionResult.result.rows[rowIndex]?.values ?? [''];
+  };
+
+  findResultValueFromCoordinates = (
+    resultCoordinate: [number, number],
+  ): string | number | boolean | null | undefined => {
+    const rowIndex = resultCoordinate[0];
+    const colIndex = resultCoordinate[1];
+
+    if (
+      !this.executionResult ||
+      !(this.executionResult instanceof TDSExecutionResult)
+    ) {
+      return undefined;
+    }
+
+    return this.executionResult.result.rows[rowIndex]?.values[colIndex];
+  };
+
   get checkForStaleResults(): boolean {
     if (this.latestRunHashCode !== this.queryBuilderState.hashCode) {
       return true;

package/src/stores/fetch-structure/tds/post-filter/QueryBuilderPostFilterState.ts

@@ -569,6 +569,7 @@ export class QueryBuilderPostFilterState
         undefined,
         QUERY_BUILDER_GROUP_OPERATION.AND,
       );
+
       groupNode.addChildNode(rootNode);
       groupNode.addChildNode(node);
       this.rootIds = [groupNode.id];

package/src/stores/shared/LambdaParameterState.ts

@@ -235,6 +235,7 @@ export class LambdaParameterState implements Hashable {
         this.parameter,
         this.graph,
         this.observerContext,
+        { useCurrentDateDependentFunctions: true },
       ),
     );
   }

package/src/stores/shared/ValueSpecificationEditorHelper.ts

@@ -41,16 +41,22 @@ import {
   Multiplicity,
   CORE_PURE_PATH,
   buildRawLambdaFromLambdaFunction,
+  getValueSpecificationReturnType,
 } from '@finos/legend-graph';
-import { Randomizer, UnsupportedOperationError } from '@finos/legend-shared';
+import {
+  Randomizer,
+  UnsupportedOperationError,
+  returnUndefOnError,
+} from '@finos/legend-shared';
 import { generateDefaultValueForPrimitiveType } from '../QueryBuilderValueSpecificationHelper.js';
 import {
   instanceValue_setValues,
   valueSpecification_setGenericType,
 } from './ValueSpecificationModifierHelper.js';
-import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../graph/QueryBuilderMetaModelConst.js';
-
-const VAR_DEFAULT_NAME = 'var';
+import {
+  QUERY_BUILDER_PURE_PATH,
+  QUERY_BUILDER_SUPPORTED_FUNCTIONS,
+} from '../../graph/QueryBuilderMetaModelConst.js';
 
 export const createSupportedFunctionExpression = (
   supportedFuncName: string,
@@ -63,52 +69,60 @@ export const createSupportedFunctionExpression = (
   );
   return funcExpression;
 };
+export const buildPrimitiveInstanceValue = (
+  graph: PureModel,
+  type: PRIMITIVE_TYPE,
+  value: unknown,
+  observerContext: ObserverContext,
+): PrimitiveInstanceValue => {
+  const instance = new PrimitiveInstanceValue(
+    GenericTypeExplicitReference.create(
+      new GenericType(graph.getPrimitiveType(type)),
+    ),
+  );
+  instanceValue_setValues(instance, [value], observerContext);
+  return instance;
+};
 
 const createMockPrimitiveValueSpecification = (
   primitiveType: PrimitiveType,
-  propertyName: string,
+  graph: PureModel,
   observerContext: ObserverContext,
+  options?: {
+    useCurrentDateDependentFunctions?: boolean;
+  },
 ): ValueSpecification => {
   const primitiveTypeName = primitiveType.name;
-  if (
-    primitiveTypeName === PRIMITIVE_TYPE.DATE ||
-    primitiveTypeName === PRIMITIVE_TYPE.DATETIME
-  ) {
-    return createSupportedFunctionExpression(
-      QUERY_BUILDER_SUPPORTED_FUNCTIONS.NOW,
-      PrimitiveType.DATETIME,
-    );
-  } else if (primitiveTypeName === PRIMITIVE_TYPE.STRICTDATE) {
-    return createSupportedFunctionExpression(
-      QUERY_BUILDER_SUPPORTED_FUNCTIONS.TODAY,
-      PrimitiveType.STRICTDATE,
+  if (options?.useCurrentDateDependentFunctions) {
+    if (
+      primitiveTypeName === PRIMITIVE_TYPE.DATE ||
+      primitiveTypeName === PRIMITIVE_TYPE.DATETIME
+    ) {
+      return createSupportedFunctionExpression(
+        QUERY_BUILDER_SUPPORTED_FUNCTIONS.NOW,
+        PrimitiveType.DATETIME,
+      );
+    } else if (primitiveTypeName === PRIMITIVE_TYPE.STRICTDATE) {
+      return createSupportedFunctionExpression(
+        QUERY_BUILDER_SUPPORTED_FUNCTIONS.TODAY,
+        PrimitiveType.STRICTDATE,
+      );
+    }
+  }
+  if (primitiveTypeName === PRIMITIVE_TYPE.DATE) {
+    return buildPrimitiveInstanceValue(
+      graph,
+      PRIMITIVE_TYPE.STRICTDATE,
+      generateDefaultValueForPrimitiveType(primitiveTypeName),
+      observerContext,
     );
   }
-  const primitiveInstanceValue = new PrimitiveInstanceValue(
-    GenericTypeExplicitReference.create(new GenericType(primitiveType)),
+  return buildPrimitiveInstanceValue(
+    graph,
+    primitiveTypeName as PRIMITIVE_TYPE,
+    generateDefaultValueForPrimitiveType(primitiveTypeName as PRIMITIVE_TYPE),
+    observerContext,
   );
-  const randomizer = new Randomizer();
-  let value: string | boolean | number;
-  switch (primitiveType.name) {
-    case PRIMITIVE_TYPE.BOOLEAN:
-      value = randomizer.getRandomItemInCollection([true, false]) ?? true;
-      break;
-    case PRIMITIVE_TYPE.FLOAT:
-      value = randomizer.getRandomFloat();
-      break;
-    case PRIMITIVE_TYPE.DECIMAL:
-      value = randomizer.getRandomDouble();
-      break;
-    case PRIMITIVE_TYPE.NUMBER:
-    case PRIMITIVE_TYPE.INTEGER:
-      value = randomizer.getRandomWholeNumber(100);
-      break;
-    case PRIMITIVE_TYPE.STRING:
-    default:
-      value = `${propertyName} ${randomizer.getRandomWholeNumber(100)}`;
-  }
-  instanceValue_setValues(primitiveInstanceValue, [value], observerContext);
-  return primitiveInstanceValue;
 };
 
 export const createMockEnumerationProperty = (
@@ -116,21 +130,6 @@ export const createMockEnumerationProperty = (
 ): string =>
   new Randomizer().getRandomItemInCollection(enumeration.values)?.name ?? '';
 
-export const buildPrimitiveInstanceValue = (
-  graph: PureModel,
-  type: PRIMITIVE_TYPE,
-  value: unknown,
-  observerContext: ObserverContext,
-): PrimitiveInstanceValue => {
-  const instance = new PrimitiveInstanceValue(
-    GenericTypeExplicitReference.create(
-      new GenericType(graph.getPrimitiveType(type)),
-    ),
-  );
-  instanceValue_setValues(instance, [value], observerContext);
-  return instance;
-};
-
 export const buildDefaultInstanceValue = (
   graph: PureModel,
   type: Type,
@@ -219,6 +218,9 @@ export const generateVariableExpressionMockValue = (
   parameter: VariableExpression,
   graph: PureModel,
   observerContext: ObserverContext,
+  options?: {
+    useCurrentDateDependentFunctions?: boolean;
+  },
 ): ValueSpecification | undefined => {
   const varType = parameter.genericType?.value.rawType;
   const multiplicity = parameter.multiplicity;
@@ -231,8 +233,9 @@ export const generateVariableExpressionMockValue = (
   if (varType instanceof PrimitiveType) {
     return createMockPrimitiveValueSpecification(
       varType,
-      VAR_DEFAULT_NAME,
+      graph,
       observerContext,
+      options,
     );
   } else if (varType instanceof Enumeration) {
     const enumValueInstance = new EnumValueInstanceValue(
@@ -272,3 +275,23 @@ export const getValueSpecificationStringValue = (
   }
   return undefined;
 };
+
+export const valueSpecReturnTDS = (
+  val: ValueSpecification,
+  graph: PureModel,
+): boolean => {
+  const retunType = returnUndefOnError(() =>
+    getValueSpecificationReturnType(val),
+  );
+  const tdsType = returnUndefOnError(() =>
+    graph.getClass(QUERY_BUILDER_PURE_PATH.TDS_TABULAR_DATASET),
+  );
+  const tdsRowType = returnUndefOnError(() =>
+    graph.getClass(QUERY_BUILDER_PURE_PATH.TDS_ROW),
+  );
+  // FIXME: we sometimes return tds row when tds is the return type of the lambda. We do this to properly build post filters.
+  // We should fix this to properly build filter functions after a tds function
+  return Boolean(
+    retunType && tdsType && (retunType === tdsType || retunType === tdsRowType),
+  );
+};