@finos/legend-query-builder 4.9.4 → 4.10.0

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

@@ -21,10 +21,12 @@ import {
   type ValueSpecification,
   type ExecutionResult,
   type VariableExpression,
+  type SimpleFunctionExpression,
   Enumeration,
   PRIMITIVE_TYPE,
   observe_ValueSpecification,
   PrimitiveType,
+  CollectionInstanceValue,
 } from '@finos/legend-graph';
 import {
   type GeneratorFn,
@@ -70,7 +72,12 @@ import { QUERY_BUILDER_GROUP_OPERATION } from '../../../QueryBuilderGroupOperati
 import type { QueryBuilderTDSState } from '../QueryBuilderTDSState.js';
 import { QUERY_BUILDER_STATE_HASH_STRUCTURE } from '../../../QueryBuilderStateHashUtils.js';
 import type { QueryBuilderTDSColumnState } from '../QueryBuilderTDSColumnState.js';
-import { isValueExpressionReferencedInValue } from '../../../QueryBuilderValueSpecificationHelper.js';
+import {
+  getCollectionValueSpecificationType,
+  getNonCollectionValueSpecificationType,
+  isValueExpressionReferencedInValue,
+} from '../../../QueryBuilderValueSpecificationHelper.js';
+import { buildtdsPropertyExpressionFromColState } from './operators/QueryBuilderPostFilterOperatorValueSpecificationBuilder.js';
 
 export enum QUERY_BUILDER_POST_FILTER_DND_TYPE {
   GROUP_CONDITION = 'GROUP_CONDITION',
@@ -207,8 +214,8 @@ export class QueryBuilderPostFilterTreeGroupNodeData
     super(parentId);
     makeObservable(this, {
       groupOperation: observable,
-      childrenIds: observable,
       setGroupOperation: action,
+      childrenIds: observable,
       addChildNode: action,
       removeChildNode: action,
       dragPreviewLabel: computed,
@@ -307,10 +314,130 @@ export class QueryBuilderPostFilterTreeBlankConditionNodeData
   }
 }
 
+export abstract class PostFilterConditionValueState implements Hashable {
+  conditionState: PostFilterConditionState;
+
+  constructor(conditionState: PostFilterConditionState) {
+    this.conditionState = conditionState;
+  }
+
+  get type(): Type | undefined {
+    return undefined;
+  }
+
+  get isCollection(): boolean {
+    return false;
+  }
+
+  get hashCode(): string {
+    return hashArray([
+      QUERY_BUILDER_STATE_HASH_STRUCTURE.POST_FILTER_CONDITION_RIGHT_VALUE,
+    ]);
+  }
+
+  abstract appendConditionValue(expressionVal: SimpleFunctionExpression): void;
+}
+
+export class PostFilterValueSpecConditionValueState extends PostFilterConditionValueState {
+  value?: ValueSpecification | undefined;
+
+  constructor(
+    conditionState: PostFilterConditionState,
+    value?: ValueSpecification | undefined,
+  ) {
+    super(conditionState);
+    makeObservable(this, {
+      value: observable,
+      setValue: action,
+    });
+    this.value = this.setValue(value);
+  }
+
+  override get type(): Type | undefined {
+    if (this.value instanceof CollectionInstanceValue) {
+      return getCollectionValueSpecificationType(
+        this.conditionState.postFilterState.tdsState.queryBuilderState
+          .graphManagerState.graph,
+        this.value.values,
+      );
+    }
+    return this.value
+      ? getNonCollectionValueSpecificationType(this.value)
+      : undefined;
+  }
+
+  setValue(
+    val: ValueSpecification | undefined,
+  ): ValueSpecification | undefined {
+    this.value = val
+      ? observe_ValueSpecification(
+          val,
+          this.conditionState.postFilterState.tdsState.queryBuilderState
+            .observerContext,
+        )
+      : undefined;
+    return this.value;
+  }
+  override appendConditionValue(expressionVal: SimpleFunctionExpression): void {
+    if (this.value) {
+      expressionVal.parametersValues.push(this.value);
+    }
+  }
+
+  override get isCollection(): boolean {
+    return this.value instanceof CollectionInstanceValue;
+  }
+
+  override get hashCode(): string {
+    return hashArray([
+      QUERY_BUILDER_STATE_HASH_STRUCTURE.POST_FILTER_CONDITION_RIGHT_VALUE_SPEC,
+      this.value,
+    ]);
+  }
+}
+
+export class PostFilterTDSColumnValueConditionValueState extends PostFilterConditionValueState {
+  tdsColumn: QueryBuilderTDSColumnState;
+
+  constructor(
+    conditionState: PostFilterConditionState,
+    tdsColumn: QueryBuilderTDSColumnState,
+  ) {
+    super(conditionState);
+    makeObservable(this, {
+      tdsColumn: observable,
+      changeCol: action,
+    });
+    this.tdsColumn = tdsColumn;
+  }
+
+  override get type(): Type | undefined {
+    return this.tdsColumn.getColumnType();
+  }
+
+  override get isCollection(): boolean {
+    return false;
+  }
+  override appendConditionValue(expressionVal: SimpleFunctionExpression): void {
+    const tdsPropertyExpression = buildtdsPropertyExpressionFromColState(
+      this.conditionState,
+      this.tdsColumn,
+      this.conditionState.postFilterState.tdsState.queryBuilderState
+        .graphManagerState.graph,
+      undefined,
+    );
+    expressionVal.parametersValues.push(tdsPropertyExpression);
+  }
+
+  changeCol(col: QueryBuilderTDSColumnState): void {
+    this.tdsColumn = col;
+  }
+}
+
 export class PostFilterConditionState implements Hashable {
   readonly postFilterState: QueryBuilderPostFilterState;
-  columnState: QueryBuilderTDSColumnState;
-  value?: ValueSpecification | undefined;
+  leftConditionValue: QueryBuilderTDSColumnState;
+  rightConditionValue: PostFilterConditionValueState;
   operator: QueryBuilderPostFilterOperator;
   typeaheadSearchResults: string[] | undefined;
   typeaheadSearchState = ActionState.create();
@@ -318,18 +445,18 @@ export class PostFilterConditionState implements Hashable {
   constructor(
     postFilterState: QueryBuilderPostFilterState,
     colState: QueryBuilderTDSColumnState,
-    value: ValueSpecification | undefined,
     operator: QueryBuilderPostFilterOperator | undefined,
   ) {
     makeObservable(this, {
       postFilterState: observable,
-      value: observable,
+      rightConditionValue: observable,
       operator: observable,
-      columnState: observable,
+      leftConditionValue: observable,
       typeaheadSearchResults: observable,
       changeOperator: action,
       setColumnState: action,
-      setValue: action,
+      setRightConditionVal: action,
+      buildFromValueSpec: action,
       setOperator: action,
       changeColumn: flow,
       handleTypeaheadSearch: flow,
@@ -338,21 +465,24 @@ export class PostFilterConditionState implements Hashable {
     });
 
     this.postFilterState = postFilterState;
-    this.columnState = colState;
-    this.setValue(value);
+    this.leftConditionValue = colState;
+    this.rightConditionValue = new PostFilterValueSpecConditionValueState(
+      this,
+      undefined,
+    );
     if (operator) {
       this.operator = operator;
     } else {
       assertTrue(
         this.operators.length !== 0,
-        `Can't find an operator for column '${this.columnState.columnName}`,
+        `Can't find an operator for column '${this.leftConditionValue.columnName}`,
       );
       this.operator = guaranteeNonNullable(this.operators[0]);
     }
   }
 
   get columnName(): string {
-    return this.columnState.columnName;
+    return this.leftConditionValue.columnName;
   }
 
   get operators(): QueryBuilderPostFilterOperator[] {
@@ -361,23 +491,43 @@ export class PostFilterConditionState implements Hashable {
     );
   }
 
+  setRightConditionVal(val: PostFilterConditionValueState): void {
+    this.rightConditionValue = val;
+  }
+
+  buildFromValueSpec(val: ValueSpecification | undefined): void {
+    if (
+      this.rightConditionValue instanceof PostFilterValueSpecConditionValueState
+    ) {
+      this.rightConditionValue.setValue(val);
+      return;
+    } else {
+      this.setRightConditionVal(
+        new PostFilterValueSpecConditionValueState(this, val),
+      );
+    }
+  }
   *handleTypeaheadSearch(): GeneratorFn<void> {
     try {
       this.typeaheadSearchState.inProgress();
       this.typeaheadSearchResults = undefined;
       const _columnState =
-        this.columnState instanceof QueryBuilderProjectionColumnState ||
-        this.columnState instanceof QueryBuilderAggregateColumnState
-          ? this.columnState
+        this.leftConditionValue instanceof QueryBuilderProjectionColumnState ||
+        this.leftConditionValue instanceof QueryBuilderAggregateColumnState
+          ? this.leftConditionValue
           : undefined;
       const columnState = guaranteeNonNullable(_columnState);
-      if (performTypeahead(this.value)) {
+      const rightConditionValue = guaranteeType(
+        this.rightConditionValue,
+        PostFilterValueSpecConditionValueState,
+      );
+      if (performTypeahead(rightConditionValue.value)) {
         const result =
           (yield this.postFilterState.tdsState.queryBuilderState.graphManagerState.graphManager.runQuery(
             buildProjectionColumnTypeaheadQuery(
               this.postFilterState.tdsState.queryBuilderState,
               columnState,
-              this.value,
+              rightConditionValue.value,
             ),
             guaranteeNonNullable(
               this.postFilterState.tdsState.queryBuilderState
@@ -404,23 +554,15 @@ export class PostFilterConditionState implements Hashable {
   changeOperator(val: QueryBuilderPostFilterOperator): void {
     this.setOperator(val);
     if (!this.operator.isCompatibleWithConditionValue(this)) {
-      this.setValue(this.operator.getDefaultFilterConditionValue(this));
+      this.buildFromValueSpec(
+        this.operator.getDefaultFilterConditionValue(this),
+      );
     }
   }
-
-  setValue(val: ValueSpecification | undefined): void {
-    this.value = val
-      ? observe_ValueSpecification(
-          val,
-          this.postFilterState.tdsState.queryBuilderState.observerContext,
-        )
-      : undefined;
-  }
-
   setColumnState(
     val: QueryBuilderProjectionColumnState | QueryBuilderAggregateColumnState,
   ): void {
-    this.columnState = val;
+    this.leftConditionValue = val;
   }
 
   setOperator(val: QueryBuilderPostFilterOperator): void {
@@ -450,7 +592,9 @@ export class PostFilterConditionState implements Hashable {
 
       // value
       if (!this.operator.isCompatibleWithConditionValue(this)) {
-        this.setValue(this.operator.getDefaultFilterConditionValue(this));
+        this.buildFromValueSpec(
+          this.operator.getDefaultFilterConditionValue(this),
+        );
       }
     } catch (error) {
       assertErrorThrown(error);
@@ -463,8 +607,8 @@ export class PostFilterConditionState implements Hashable {
   get hashCode(): string {
     return hashArray([
       QUERY_BUILDER_STATE_HASH_STRUCTURE.POST_FILTER_CONDITION_STATE,
-      this.columnState,
-      this.value ?? '',
+      this.leftConditionValue,
+      this.rightConditionValue,
       this.operator,
     ]);
   }
@@ -555,7 +699,7 @@ export class QueryBuilderPostFilterState
     return uniq(
       Array.from(this.nodes.values())
         .filter(filterByType(QueryBuilderPostFilterTreeConditionNodeData))
-        .map((n) => n.condition.columnState),
+        .map((n) => n.condition.leftConditionValue),
     );
   }
 
@@ -883,7 +1027,9 @@ export class QueryBuilderPostFilterState
     return Boolean(
       Array.from(this.nodes.values())
         .filter(filterByType(QueryBuilderPostFilterTreeConditionNodeData))
-        .map((node) => node.condition.value)
+        .map((node) => node.condition.rightConditionValue)
+        .filter(filterByType(PostFilterValueSpecConditionValueState))
+        .map((condition) => condition.value)
         .filter(isNonNullable)
         .find((value) => isValueExpressionReferencedInValue(variable, value)),
     );

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

@@ -23,6 +23,7 @@ import {
   VariableExpression,
   FunctionExpression,
   type SimpleFunctionExpression,
+  type ValueSpecification,
 } from '@finos/legend-graph';
 import {
   assertTrue,
@@ -30,6 +31,7 @@ import {
   guaranteeIsString,
   guaranteeNonNullable,
   guaranteeType,
+  returnUndefOnError,
   UnsupportedOperationError,
 } from '@finos/legend-shared';
 import { QueryBuilderDerivationProjectionColumnState } from '../projection/QueryBuilderProjectionColumnState.js';
@@ -44,6 +46,8 @@ import {
   QueryBuilderPostFilterTreeGroupNodeData,
   TDS_COLUMN_GETTER,
   getTypeFromDerivedProperty,
+  PostFilterValueSpecConditionValueState,
+  PostFilterTDSColumnValueConditionValueState,
 } from './QueryBuilderPostFilterState.js';
 import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../../graph/QueryBuilderMetaModelConst.js';
 import type { QueryBuilderState } from '../../../QueryBuilderState.js';
@@ -102,6 +106,36 @@ const findProjectionColumnState = (
   return columnState;
 };
 
+const buildPostFilterConditionValueState = (
+  rightVal: ValueSpecification | undefined,
+  conditionState: PostFilterConditionState,
+): void => {
+  if (rightVal instanceof AbstractPropertyExpression) {
+    const rightCol = returnUndefOnError(() =>
+      findProjectionColumnState(rightVal, conditionState.postFilterState),
+    );
+    if (rightCol) {
+      conditionState.setRightConditionVal(
+        new PostFilterTDSColumnValueConditionValueState(
+          conditionState,
+          rightCol,
+        ),
+      );
+      return;
+    }
+  }
+  const val = rightVal
+    ? simplifyValueExpression(
+        rightVal,
+        conditionState.postFilterState.tdsState.queryBuilderState
+          .observerContext,
+      )
+    : undefined;
+  conditionState.setRightConditionVal(
+    new PostFilterValueSpecConditionValueState(conditionState, val),
+  );
+};
+
 export const buildPostFilterConditionState = (
   postFilterState: QueryBuilderPostFilterState,
   expression: FunctionExpression,
@@ -119,7 +153,6 @@ export const buildPostFilterConditionState = (
     postConditionState = new PostFilterConditionState(
       postFilterState,
       columnState,
-      undefined,
       operator,
     );
     return postConditionState;
@@ -150,21 +183,17 @@ export const buildPostFilterConditionState = (
     );
 
     // get operation value specification
-    const value = expression.parametersValues[1];
+    const rightSide = expression.parametersValues[1];
 
     // create state
     postConditionState = new PostFilterConditionState(
       postFilterState,
       columnState,
-      value
-        ? simplifyValueExpression(
-            value,
-            postFilterState.tdsState.queryBuilderState.observerContext,
-          )
-        : undefined,
       operator,
     );
 
+    buildPostFilterConditionValueState(rightSide, postConditionState);
+
     //post checks
     assertTrue(
       operator.isCompatibleWithPostFilterColumn(postConditionState),
@@ -174,7 +203,7 @@ export const buildPostFilterConditionState = (
     );
     assertTrue(
       operator.isCompatibleWithConditionValue(postConditionState),
-      `Operator '${operator.getLabel()}' not compatible with value specification ${value?.toString()}`,
+      `Operator '${operator.getLabel()}' not compatible with value specification ${rightSide?.toString()}`,
     );
   }
   return postConditionState;

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

@@ -27,6 +27,7 @@ import {
   PropertyExplicitReference,
   Multiplicity,
   PrimitiveType,
+  type PureModel,
 } from '@finos/legend-graph';
 import { guaranteeNonNullable } from '@finos/legend-shared';
 import type { QueryBuilderPostFilterOperator } from '../QueryBuilderPostFilterOperator.js';
@@ -36,27 +37,19 @@ import {
   getTDSColumnDerivedProperyFromType,
 } from '../QueryBuilderPostFilterState.js';
 import { QUERY_BUILDER_PURE_PATH } from '../../../../../graph/QueryBuilderMetaModelConst.js';
+import type { QueryBuilderTDSColumnState } from '../../QueryBuilderTDSColumnState.js';
 
-export const buildPostFilterConditionExpression = (
+export const buildtdsPropertyExpressionFromColState = (
   filterConditionState: PostFilterConditionState,
-  operator: QueryBuilderPostFilterOperator,
-  /**
-   * If provided, this will be used to construct the simple
-   * function expression for the function with the specified
-   * name. If not provided, we will fall back to use the TDS column getter function expression.
-   * This is the case because with TDS, we are provided some filter-like operators, e.g. IS_NULL, IS_NOT_NULL, etc.
-   */
-  operatorFunctionFullPath: string | undefined,
-): FunctionExpression => {
-  // primitives
-  const graph =
-    filterConditionState.postFilterState.tdsState.queryBuilderState
-      .graphManagerState.graph;
-  // property expression
-  const colState = filterConditionState.columnState;
+  colState: QueryBuilderTDSColumnState,
+  graph: PureModel,
+  operator: QueryBuilderPostFilterOperator | undefined,
+): AbstractPropertyExpression => {
   const tdsPropertyExpression = new AbstractPropertyExpression('');
   let tdsDerivedPropertyName: TDS_COLUMN_GETTER;
-  const correspondingTDSDerivedProperty = operator.getTDSColumnGetter();
+  const correspondingTDSDerivedProperty = operator
+    ? operator.getTDSColumnGetter()
+    : undefined;
   if (correspondingTDSDerivedProperty) {
     tdsDerivedPropertyName = correspondingTDSDerivedProperty;
   } else {
@@ -79,15 +72,38 @@ export const buildPostFilterConditionExpression = (
   );
   colInstanceValue.values = [colState.columnName];
   tdsPropertyExpression.parametersValues = [variableName, colInstanceValue];
+  return tdsPropertyExpression;
+};
+
+export const buildPostFilterConditionExpression = (
+  filterConditionState: PostFilterConditionState,
+  operator: QueryBuilderPostFilterOperator,
+  /**
+   * If provided, this will be used to construct the simple
+   * function expression for the function with the specified
+   * name. If not provided, we will fall back to use the TDS column getter function expression.
+   * This is the case because with TDS, we are provided some filter-like operators, e.g. IS_NULL, IS_NOT_NULL, etc.
+   */
+  operatorFunctionFullPath: string | undefined,
+): FunctionExpression => {
+  // primitives
+  const graph =
+    filterConditionState.postFilterState.tdsState.queryBuilderState
+      .graphManagerState.graph;
+  // property expression
+  const tdsPropertyExpression = buildtdsPropertyExpressionFromColState(
+    filterConditionState,
+    filterConditionState.leftConditionValue,
+    graph,
+    operator,
+  );
 
   if (operatorFunctionFullPath) {
     const expression = new SimpleFunctionExpression(
       extractElementNameFromPath(operatorFunctionFullPath),
     );
     expression.parametersValues.push(tdsPropertyExpression);
-    if (filterConditionState.value) {
-      expression.parametersValues.push(filterConditionState.value);
-    }
+    filterConditionState.rightConditionValue.appendConditionValue(expression);
     return expression;
   } else {
     return tdsPropertyExpression;

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

@@ -37,7 +37,6 @@ import type {
 import {
   buildNotExpression,
   generateDefaultValueForPrimitiveType,
-  getNonCollectionValueSpecificationType,
   unwrapNotExpression,
 } from '../../../../QueryBuilderValueSpecificationHelper.js';
 import { buildPostFilterConditionExpression } from './QueryBuilderPostFilterOperatorValueSpecificationBuilder.js';
@@ -60,17 +59,17 @@ export class QueryBuilderPostFilterOperator_Contain
   isCompatibleWithConditionValue(
     postFilterConditionState: PostFilterConditionState,
   ): boolean {
-    const type = postFilterConditionState.value
-      ? getNonCollectionValueSpecificationType(postFilterConditionState.value)
-      : undefined;
-    return PrimitiveType.STRING === type;
+    return (
+      !postFilterConditionState.rightConditionValue.isCollection &&
+      PrimitiveType.STRING === postFilterConditionState.rightConditionValue.type
+    );
   }
 
   getDefaultFilterConditionValue(
     postFilterConditionState: PostFilterConditionState,
   ): ValueSpecification {
     const propertyType = guaranteeNonNullable(
-      postFilterConditionState.columnState.getColumnType(),
+      postFilterConditionState.leftConditionValue.getColumnType(),
     );
     switch (propertyType.path) {
       case PRIMITIVE_TYPE.STRING: {

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

@@ -35,7 +35,6 @@ import type {
 import {
   buildNotExpression,
   generateDefaultValueForPrimitiveType,
-  getNonCollectionValueSpecificationType,
   unwrapNotExpression,
 } from '../../../../QueryBuilderValueSpecificationHelper.js';
 import { buildPostFilterConditionExpression } from './QueryBuilderPostFilterOperatorValueSpecificationBuilder.js';
@@ -58,16 +57,17 @@ export class QueryBuilderPostFilterOperator_EndWith
   isCompatibleWithConditionValue(
     postFilterConditionState: PostFilterConditionState,
   ): boolean {
-    const type = postFilterConditionState.value
-      ? getNonCollectionValueSpecificationType(postFilterConditionState.value)
-      : undefined;
-    return PrimitiveType.STRING === type;
+    return (
+      !postFilterConditionState.rightConditionValue.isCollection &&
+      PrimitiveType.STRING === postFilterConditionState.rightConditionValue.type
+    );
   }
 
   getDefaultFilterConditionValue(
     postFilterConditionState: PostFilterConditionState,
   ): ValueSpecification {
-    const propertyType = postFilterConditionState.columnState.getColumnType();
+    const propertyType =
+      postFilterConditionState.leftConditionValue.getColumnType();
     switch (propertyType?.path) {
       case PRIMITIVE_TYPE.STRING: {
         return buildPrimitiveInstanceValue(

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

@@ -27,6 +27,7 @@ import {
   GenericType,
   GenericTypeExplicitReference,
   PRIMITIVE_TYPE,
+  PrimitiveType,
 } from '@finos/legend-graph';
 import {
   guaranteeNonNullable,
@@ -36,14 +37,13 @@ import {
 } from '@finos/legend-shared';
 import { QueryBuilderPostFilterOperator } from '../QueryBuilderPostFilterOperator.js';
 import { buildPostFilterConditionState } from '../QueryBuilderPostFilterStateBuilder.js';
-import type {
-  PostFilterConditionState,
-  QueryBuilderPostFilterState,
+import {
+  type PostFilterConditionState,
+  type QueryBuilderPostFilterState,
 } from '../QueryBuilderPostFilterState.js';
 import {
   buildNotExpression,
   generateDefaultValueForPrimitiveType,
-  getNonCollectionValueSpecificationType,
   isTypeCompatibleForAssignment,
   unwrapNotExpression,
 } from '../../../../QueryBuilderValueSpecificationHelper.js';
@@ -84,12 +84,11 @@ export class QueryBuilderPostFilterOperator_Equal
   isCompatibleWithConditionValue(
     postFilterConditionState: PostFilterConditionState,
   ): boolean {
-    const valueSpecification = postFilterConditionState.value;
-    if (valueSpecification) {
+    if (!postFilterConditionState.rightConditionValue.isCollection) {
       return isTypeCompatibleForAssignment(
-        getNonCollectionValueSpecificationType(valueSpecification),
+        postFilterConditionState.rightConditionValue.type,
         guaranteeNonNullable(
-          postFilterConditionState.columnState.getColumnType(),
+          postFilterConditionState.leftConditionValue.getColumnType(),
         ),
       );
     }
@@ -100,7 +99,7 @@ export class QueryBuilderPostFilterOperator_Equal
     postFilterConditionState: PostFilterConditionState,
   ): ValueSpecification {
     const propertyType = guaranteeNonNullable(
-      postFilterConditionState.columnState.getColumnType(),
+      postFilterConditionState.leftConditionValue.getColumnType(),
     );
     switch (propertyType.path) {
       case PRIMITIVE_TYPE.STRING:
@@ -170,10 +169,10 @@ export class QueryBuilderPostFilterOperator_Equal
     return buildPostFilterConditionExpression(
       postFilterConditionState,
       this,
-      postFilterConditionState.columnState.getColumnType()?.path ===
-        PRIMITIVE_TYPE.DATETIME &&
-        postFilterConditionState.value?.genericType?.value.rawType.path !==
-          PRIMITIVE_TYPE.DATETIME
+      postFilterConditionState.leftConditionValue.getColumnType() ===
+        PrimitiveType.DATETIME &&
+        postFilterConditionState.rightConditionValue.type !==
+          PrimitiveType.DATETIME
         ? QUERY_BUILDER_SUPPORTED_FUNCTIONS.IS_ON_DAY
         : QUERY_BUILDER_SUPPORTED_FUNCTIONS.EQUAL,
     );