@finos/legend-data-cube 0.0.41 → 0.0.43

package/src/stores/core/DataCubeQuerySnapshotBuilderUtils.ts

@@ -28,25 +28,32 @@ import {
   V1_ClassInstance,
   V1_ColSpec,
   V1_ColSpecArray,
-  V1_Lambda,
+  V1_GenericTypeInstance,
   type V1_ValueSpecification,
-  type V1_PrimitiveValueSpecification,
+  V1_PrimitiveValueSpecification,
   extractElementNameFromPath as _name,
   matchFunctionName,
+  V1_RelationType,
+  V1_PackageableType,
+  type V1_GenericType,
 } from '@finos/legend-graph';
 import { type DataCubeColumn } from './model/DataCubeColumn.js';
 import {
   assertTrue,
   assertType,
+  at,
   guaranteeNonNullable,
   guaranteeType,
+  IllegalStateError,
+  uniq,
   UnsupportedOperationError,
   type Clazz,
 } from '@finos/legend-shared';
 import {
   DataCubeFunction,
+  DataCubeOperationAdvancedValueType,
   DataCubeQueryFilterGroupOperator,
-  DataCubeQueryFilterOperator,
+  getDataType,
   TREE_COLUMN_VALUE_SEPARATOR,
   type DataCubeOperationValue,
 } from './DataCubeQueryEngine.js';
@@ -54,7 +61,7 @@ import type {
   DataCubeQuerySnapshotFilter,
   DataCubeQuerySnapshotFilterCondition,
 } from './DataCubeQuerySnapshot.js';
-import { _functionName } from './DataCubeQueryBuilderUtils.js';
+import { _serializeValueSpecification } from './DataCubeQueryBuilderUtils.js';
 import type { DataCubeQueryFilterOperation } from './filter/DataCubeQueryFilterOperation.js';
 
 // --------------------------------- UTILITIES ---------------------------------
@@ -63,6 +70,7 @@ export function _param<T extends V1_ValueSpecification>(
   func: V1_AppliedFunction,
   paramIdx: number,
   clazz: Clazz<T>,
+  message?: string | undefined,
 ): T {
   assertTrue(
     func.parameters.length >= paramIdx + 1,
@@ -71,7 +79,8 @@ export function _param<T extends V1_ValueSpecification>(
   return guaranteeType(
     func.parameters[paramIdx],
     clazz,
-    `Can't process ${_name(func.function)}() expression: Found unexpected type for parameter at index ${paramIdx}`,
+    message ??
+      `Can't process ${_name(func.function)}() expression: Found unexpected type for parameter at index ${paramIdx}`,
   );
 }
 
@@ -83,14 +92,6 @@ export function _colSpecParam(func: V1_AppliedFunction, paramIdx: number) {
   );
 }
 
-export function _lambdaParam(func: V1_AppliedFunction, paramIdx: number) {
-  return guaranteeType(
-    _param(func, paramIdx, V1_Lambda),
-    V1_Lambda,
-    `Can't process ${_name(func.function)}: Expected parameter at index ${paramIdx} to be a lambda expression`,
-  );
-}
-
 export function _colSpecArrayParam(func: V1_AppliedFunction, paramIdx: number) {
   return guaranteeType(
     _param(func, paramIdx, V1_ClassInstance).value,
@@ -99,6 +100,15 @@ export function _colSpecArrayParam(func: V1_AppliedFunction, paramIdx: number) {
   );
 }
 
+export function _genericTypeParam(func: V1_AppliedFunction, paramIdx: number) {
+  return _param(
+    func,
+    paramIdx,
+    V1_GenericTypeInstance,
+    `Can't process ${_name(func.function)}: Expected parameter at index ${paramIdx} to be a generic type instance`,
+  );
+}
+
 export function _funcMatch(
   value: V1_ValueSpecification | undefined,
   functionNames: string | string[],
@@ -113,11 +123,50 @@ export function _funcMatch(
       value.function,
       Array.isArray(functionNames) ? functionNames : [functionNames],
     ),
-    `Can't process function: Expected function name to be one of [${Array.isArray(functionNames) ? functionNames.join(', ') : functionNames}]`,
+    `Can't process function: Expected function to be one of [${uniq((Array.isArray(functionNames) ? functionNames : [functionNames]).map(_name)).join(', ')}]`,
   );
   return value;
 }
 
+export function _relationType(genericType: V1_GenericType) {
+  return guaranteeType(
+    genericType.typeArguments[0]?.rawType,
+    V1_RelationType,
+    `Can't process generic type: failed to extract relation type`,
+  );
+}
+
+export function _packageableType(genericType: V1_GenericType) {
+  return guaranteeType(
+    genericType.rawType,
+    V1_PackageableType,
+    `Can't process generic type: failed to extract packageable type`,
+  );
+}
+
+export function _operationPrimitiveValue(
+  value: V1_PrimitiveValueSpecification,
+): DataCubeOperationValue {
+  if (value instanceof V1_CString) {
+    return { value: value.value, type: PRIMITIVE_TYPE.STRING };
+  } else if (value instanceof V1_CBoolean) {
+    return { value: value.value, type: PRIMITIVE_TYPE.BOOLEAN };
+  } else if (value instanceof V1_CDecimal) {
+    return { value: value.value, type: PRIMITIVE_TYPE.DECIMAL };
+  } else if (value instanceof V1_CInteger) {
+    return { value: value.value, type: PRIMITIVE_TYPE.INTEGER };
+  } else if (value instanceof V1_CFloat) {
+    return { value: value.value, type: PRIMITIVE_TYPE.FLOAT };
+  } else if (value instanceof V1_CStrictDate) {
+    return { value: value.value, type: PRIMITIVE_TYPE.STRICTDATE };
+  } else if (value instanceof V1_CDateTime) {
+    return { value: value.value, type: PRIMITIVE_TYPE.DATETIME };
+  } else if (value instanceof V1_CStrictTime) {
+    return { value: value.value, type: PRIMITIVE_TYPE.STRICTTIME };
+  }
+  throw new UnsupportedOperationError(`Can't process primitive value`);
+}
+
 // --------------------------------- BUILDING BLOCKS ---------------------------------
 
 /**
@@ -154,283 +203,306 @@ export function _pruneExpandedPaths(
     .sort();
 }
 
-export function _buildFilterSnapshot(
-  vs: V1_ValueSpecification,
-  filterOperations: DataCubeQueryFilterOperation[],
-): DataCubeQuerySnapshotFilter {
-  const filterSnapshot = {} as DataCubeQuerySnapshotFilter;
-  const filterConditionSnapshot = [];
-
-  if (vs instanceof V1_AppliedFunction) {
-    switch (vs.function) {
-      case DataCubeQueryFilterGroupOperator.OR:
-      case DataCubeQueryFilterGroupOperator.AND:
-        filterSnapshot.groupOperator = vs.function;
-        break;
-      default:
-        filterSnapshot.groupOperator = DataCubeQueryFilterGroupOperator.AND;
+export function _extractExtendedColumns(func: V1_AppliedFunction) {
+  const extendFuncs: V1_AppliedFunction[] = [];
+  let currentFunc = func;
+
+  while (currentFunc instanceof V1_AppliedFunction) {
+    // since we are processing a chain of extend(), we can finish processing when
+    // encountering a different function.
+    if (!matchFunctionName(currentFunc.function, DataCubeFunction.EXTEND)) {
+      break;
     }
 
-    if (
-      vs.function === DataCubeQueryFilterGroupOperator.AND ||
-      vs.function === DataCubeQueryFilterGroupOperator.OR
-    ) {
-      vs.parameters.forEach((param) => {
-        filterConditionSnapshot.push(_buildSubFilter(param, filterOperations)!);
-      });
+    if (currentFunc.parameters.length === 2) {
+      const valueSpecification = currentFunc.parameters[0];
+      if (!(valueSpecification instanceof V1_AppliedFunction)) {
+        throw new IllegalStateError(
+          `Can't process extend() expression: Expected a chain of function calls (e.g. x()->y()->z())`,
+        );
+      } else {
+        currentFunc.parameters = currentFunc.parameters.slice(1);
+        extendFuncs.unshift(currentFunc);
+        currentFunc = valueSpecification;
+      }
     } else {
-      filterConditionSnapshot.push(_buildSubFilter(vs, filterOperations)!);
+      assertTrue(
+        currentFunc.parameters.length === 1,
+        `Can't process extend() expression: Expected 1 parameter, got ${currentFunc.parameters.length}`,
+      );
+      extendFuncs.unshift(currentFunc);
+      break;
     }
   }
-  filterSnapshot.conditions = filterConditionSnapshot;
-  return filterSnapshot;
+  return extendFuncs.map((extendFunc) => {
+    const colSpecs = _colSpecArrayParam(extendFunc, 0).colSpecs;
+    assertTrue(
+      colSpecs.length === 1,
+      `Can't process extend() expression: Expected 1 column specification, got ${colSpecs.length}`,
+    );
+    const colSpec = at(colSpecs, 0);
+    return {
+      name: colSpec.name,
+      type: '', // NOTE: we don't have type information for extended columns at this point
+      mapFn: _serializeValueSpecification(
+        guaranteeNonNullable(
+          colSpec.function1,
+          `Can't process extend() expression: Expected a transformation function expression`,
+        ),
+      ),
+      reduceFn: colSpec.function2
+        ? _serializeValueSpecification(colSpec.function2)
+        : undefined,
+    };
+  });
 }
 
-function _buildSubFilter(
-  vs: V1_ValueSpecification,
+export function _filter(
+  value: V1_ValueSpecification,
+  columnGetter: (name: string) => DataCubeColumn,
   filterOperations: DataCubeQueryFilterOperation[],
-):
-  | DataCubeQuerySnapshotFilterCondition
-  | DataCubeQuerySnapshotFilter
-  | undefined {
-  if (vs instanceof V1_AppliedFunction) {
-    if (
-      Object.values(DataCubeFunction)
-        .map((op) => _functionName(op))
-        .includes(vs.function) &&
-      vs.function !== _functionName(DataCubeFunction.NOT)
-    ) {
-      const condition = _buildFilterConditionSnapshot(vs)!;
-      return _buildDataCubeQueryFilter(
-        condition[0],
-        condition[1],
-        filterOperations,
+): DataCubeQuerySnapshotFilter {
+  if (!(value instanceof V1_AppliedFunction)) {
+    throw new Error(
+      `Can't process filter() expression: Expected a function expression`,
+    );
+  }
+
+  const group: DataCubeQuerySnapshotFilter = {
+    // default to AND group for case where there is only one condition
+    groupOperator: DataCubeQueryFilterGroupOperator.AND,
+    conditions: [],
+  };
+
+  if (matchFunctionName(value.function, DataCubeFunction.AND)) {
+    value.parameters.forEach((param) => {
+      group.conditions.push(
+        _filterCondition(param, columnGetter, filterOperations),
       );
-    } else if (vs.function === _functionName(DataCubeFunction.NOT)) {
-      const notCondition = _buildNotFilterConditionSnapshot(
-        vs.parameters[0] as V1_AppliedFunction,
+    });
+  } else if (matchFunctionName(value.function, DataCubeFunction.OR)) {
+    group.groupOperator = DataCubeQueryFilterGroupOperator.OR;
+    value.parameters.forEach((param) => {
+      group.conditions.push(
+        _filterCondition(param, columnGetter, filterOperations),
       );
-      if (notCondition) {
-        return _buildDataCubeQueryFilter(
-          notCondition[0],
-          notCondition[1],
-          filterOperations,
-        );
-      } else {
-        const filterSnapshot = _buildFilterSnapshot(
-          vs.parameters[0] as V1_ValueSpecification,
-          filterOperations,
-        );
-        filterSnapshot.not = true;
-        return filterSnapshot;
-      }
-    } else if (vs.parameters[0] instanceof V1_AppliedFunction) {
-      return _buildFilterSnapshot(vs, filterOperations);
-    }
+    });
+  } else {
+    // handles the case where the root is a simple condition or a NOT condition
+    group.conditions.push(
+      _filterCondition(value, columnGetter, filterOperations),
+    );
   }
-  return undefined;
+  return group;
 }
 
-function _buildFilterConditionSnapshot(
-  af: V1_AppliedFunction,
-): [V1_AppliedFunction, string] | undefined {
-  if (af.parameters[1] && af.parameters[1] instanceof V1_AppliedProperty) {
-    switch (af.function) {
-      case _functionName(DataCubeFunction.EQUAL):
-        return [af, DataCubeQueryFilterOperator.EQUAL_COLUMN];
-      case _functionName(DataCubeFunction.GREATER_THAN):
-        return [af, DataCubeQueryFilterOperator.GREATER_THAN_COLUMN];
-      case _functionName(DataCubeFunction.GREATER_THAN_OR_EQUAL):
-        return [af, DataCubeQueryFilterOperator.GREATER_THAN_OR_EQUAL_COLUMN];
-      case _functionName(DataCubeFunction.LESS_THAN):
-        return [af, DataCubeQueryFilterOperator.GREATER_THAN_OR_EQUAL_COLUMN];
-      case _functionName(DataCubeFunction.LESS_THAN):
-        return [af, DataCubeQueryFilterOperator.LESS_THAN_COLUMN];
-      case _functionName(DataCubeFunction.LESS_THAN_OR_EQUAL):
-        return [af, DataCubeQueryFilterOperator.LESS_THAN_OR_EQUAL_COLUMN];
-      default:
-        return undefined;
-    }
-  } else if (
-    af.parameters[0] instanceof V1_AppliedFunction &&
-    af.parameters[0].function === _functionName(DataCubeFunction.TO_LOWERCASE)
-  ) {
-    return _buildCaseInsensitiveFilterConditionSnapshot(af);
-  } else {
-    switch (af.function) {
-      case _functionName(DataCubeFunction.CONTAINS):
-        return [af, DataCubeQueryFilterOperator.CONTAIN];
-      case _functionName(DataCubeFunction.ENDS_WITH):
-        return [af, DataCubeQueryFilterOperator.END_WITH];
-      case _functionName(DataCubeFunction.EQUAL):
-        return [af, DataCubeQueryFilterOperator.EQUAL];
-      case _functionName(DataCubeFunction.GREATER_THAN):
-        return [af, DataCubeQueryFilterOperator.GREATER_THAN];
-      case _functionName(DataCubeFunction.GREATER_THAN_OR_EQUAL):
-        return [af, DataCubeQueryFilterOperator.GREATER_THAN_OR_EQUAL];
-      case _functionName(DataCubeFunction.IS_EMPTY):
-        return [af, DataCubeQueryFilterOperator.IS_NULL];
-      case _functionName(DataCubeFunction.LESS_THAN):
-        return [af, DataCubeQueryFilterOperator.LESS_THAN];
-      case _functionName(DataCubeFunction.LESS_THAN_OR_EQUAL):
-        return [af, DataCubeQueryFilterOperator.LESS_THAN_OR_EQUAL];
-      case _functionName(DataCubeFunction.STARTS_WITH):
-        return [af, DataCubeQueryFilterOperator.START_WITH];
-      default:
-        return undefined;
-    }
-  }
+export function _unwrapNotFilterCondition(func: V1_AppliedFunction) {
+  assertTrue(
+    matchFunctionName(func.function, DataCubeFunction.NOT),
+    `Can't process filter condition expression: failed to unwrap not() function`,
+  );
+  assertTrue(
+    func.parameters.length === 1,
+    `Can't process not() function: Expected 1 parameter`,
+  );
+  return _param(func, 0, V1_AppliedFunction);
 }
 
-function _buildCaseInsensitiveFilterConditionSnapshot(
-  af: V1_AppliedFunction,
-): [V1_AppliedFunction, string] | undefined {
-  const func = af;
+function _filterCondition(
+  value: V1_ValueSpecification,
+  columnGetter: (name: string) => DataCubeColumn,
+  filterOperations: DataCubeQueryFilterOperation[],
+): DataCubeQuerySnapshotFilterCondition | DataCubeQuerySnapshotFilter {
+  if (!(value instanceof V1_AppliedFunction)) {
+    throw new UnsupportedOperationError(
+      `Can't process filter condition expression: Expected a function expression`,
+    );
+  }
+
+  // handle group condition
   if (
-    af.parameters[0] instanceof V1_AppliedFunction &&
-    af.parameters[1] instanceof V1_AppliedFunction
+    matchFunctionName(value.function, [
+      DataCubeFunction.AND,
+      DataCubeFunction.OR,
+    ])
   ) {
-    func.parameters = [
-      af.parameters[0].parameters[0]!,
-      af.parameters[1].parameters[0]!,
-    ];
+    return _filter(value, columnGetter, filterOperations);
   }
-  if (func.parameters[1] && func.parameters[1] instanceof V1_AppliedProperty) {
-    switch (af.function) {
-      case _functionName(DataCubeFunction.EQUAL):
-        return [
-          func,
-          DataCubeQueryFilterOperator.EQUAL_CASE_INSENSITIVE_COLUMN,
-        ];
-      default:
-        return undefined;
-    }
-  } else {
-    switch (af.function) {
-      case _functionName(DataCubeFunction.CONTAINS):
-        return [func, DataCubeQueryFilterOperator.CONTAIN_CASE_INSENSITIVE];
-      case _functionName(DataCubeFunction.ENDS_WITH):
-        return [func, DataCubeQueryFilterOperator.END_WITH_CASE_INSENSITIVE];
-      case _functionName(DataCubeFunction.EQUAL):
-        return [func, DataCubeQueryFilterOperator.EQUAL_CASE_INSENSITIVE];
-      case _functionName(DataCubeFunction.STARTS_WITH):
-        return [func, DataCubeQueryFilterOperator.START_WITH_CASE_INSENSITIVE];
-      default:
-        return undefined;
+
+  // run through the list of supported filter operations to find the one that can process the condition
+  for (const filterOperation of filterOperations) {
+    const condition = filterOperation.buildConditionSnapshot(
+      value,
+      columnGetter,
+    );
+    if (condition) {
+      return condition;
     }
   }
-}
 
-function _buildNotFilterConditionSnapshot(
-  af: V1_AppliedFunction,
-): [V1_AppliedFunction, string] | undefined {
-  if (af.parameters[1] && af.parameters[1] instanceof V1_AppliedProperty) {
-    switch (af.function) {
-      case _functionName(DataCubeFunction.EQUAL):
-        return [af, DataCubeQueryFilterOperator.NOT_EQUAL_COLUMN];
-      default:
-        return undefined;
-    }
-  } else if (
-    af.parameters[0] instanceof V1_AppliedFunction &&
-    af.parameters[0].function === _functionName(DataCubeFunction.TO_LOWERCASE)
-  ) {
-    if (af.function === _functionName(DataCubeFunction.EQUAL)) {
-      const func = af;
-      if (
-        af.parameters[0] instanceof V1_AppliedFunction &&
-        af.parameters[1] instanceof V1_AppliedFunction
-      ) {
-        func.parameters = [
-          af.parameters[0].parameters[0]!,
-          af.parameters[1].parameters[0]!,
-        ];
-      }
-      if (
-        func.parameters[1] &&
-        func.parameters[1] instanceof V1_AppliedProperty
-      ) {
-        return [
-          func,
-          DataCubeQueryFilterOperator.NOT_EQUAL_CASE_INSENSITIVE_COLUMN,
-        ];
+  // if no match found, proceed to unwrap if it's a NOT condition
+  if (matchFunctionName(value.function, DataCubeFunction.NOT)) {
+    // run through the list of supported filter operations to find the one that can process the condition
+    // again. Processing in this order ensures cases like x != y can be recognized as NOT_EQUAL operator
+    // instead of NOT(x == y)
+    const unwrapped = _unwrapNotFilterCondition(value);
+    for (const filterOperation of filterOperations) {
+      const condition = filterOperation.buildConditionSnapshot(
+        unwrapped,
+        columnGetter,
+      );
+      if (condition) {
+        condition.not = true;
+        return condition;
       }
-      return [func, DataCubeQueryFilterOperator.NOT_EQUAL_CASE_INSENSITIVE];
     }
-  } else {
-    switch (af.function) {
-      case _functionName(DataCubeFunction.CONTAINS):
-        return [af, DataCubeQueryFilterOperator.NOT_CONTAIN];
-      case _functionName(DataCubeFunction.ENDS_WITH):
-        return [af, DataCubeQueryFilterOperator.NOT_END_WITH];
-      case _functionName(DataCubeFunction.EQUAL):
-        return [af, DataCubeQueryFilterOperator.NOT_EQUAL];
-      case _functionName(DataCubeFunction.IS_EMPTY):
-        return [af, DataCubeQueryFilterOperator.IS_NOT_NULL];
-      case _functionName(DataCubeFunction.STARTS_WITH):
-        return [af, DataCubeQueryFilterOperator.NOT_START_WITH];
-      default:
-        return undefined;
+
+    // if no match found, try to see if the condition is a group condition and process
+    if (
+      unwrapped instanceof V1_AppliedFunction &&
+      matchFunctionName(unwrapped.function, [
+        DataCubeFunction.AND,
+        DataCubeFunction.OR,
+      ])
+    ) {
+      const condition = _filter(unwrapped, columnGetter, filterOperations);
+      condition.not = true;
+      return condition;
     }
   }
-  return undefined;
+
+  // if no match found, throw error, we encountered a filter condition form that we don't support
+  throw new Error(`Can't process filter condition: no matching operator found`);
 }
 
-export function _dataCubeOperationValue(
-  vs: V1_PrimitiveValueSpecification,
-): DataCubeOperationValue {
-  switch (true) {
-    case vs instanceof V1_CString:
-      return _buildDataCubeOperationValue(PRIMITIVE_TYPE.STRING, vs.value);
-    case vs instanceof V1_CBoolean:
-      return _buildDataCubeOperationValue(PRIMITIVE_TYPE.BOOLEAN, vs.value);
-    case vs instanceof V1_CDecimal:
-      return _buildDataCubeOperationValue(PRIMITIVE_TYPE.DECIMAL, vs.value);
-    case vs instanceof V1_CInteger:
-      return _buildDataCubeOperationValue(PRIMITIVE_TYPE.INTEGER, vs.value);
-    case vs instanceof V1_CFloat:
-      return _buildDataCubeOperationValue(PRIMITIVE_TYPE.FLOAT, vs.value);
-    case vs instanceof V1_CStrictDate:
-      return _buildDataCubeOperationValue(PRIMITIVE_TYPE.STRICTDATE, vs.value);
-    case vs instanceof V1_CDateTime:
-      return _buildDataCubeOperationValue(PRIMITIVE_TYPE.DATETIME, vs.value);
-    case vs instanceof V1_CStrictTime:
-      return _buildDataCubeOperationValue(PRIMITIVE_TYPE.STRICTTIME, vs.value);
-    default:
-      throw new UnsupportedOperationError(
-        `Unsupported primitive value '${vs}'`,
-      );
+function _filterConditionValue(
+  value: V1_ValueSpecification | undefined,
+  column: DataCubeColumn,
+  columnGetter: (name: string) => DataCubeColumn,
+) {
+  if (value instanceof V1_PrimitiveValueSpecification) {
+    return _operationPrimitiveValue(value);
+  } else if (value instanceof V1_AppliedProperty) {
+    const column2 = columnGetter(value.property);
+    if (getDataType(column.type) !== getDataType(column2.type)) {
+      return undefined;
+    }
+    return {
+      value: column2.name,
+      type: DataCubeOperationAdvancedValueType.COLUMN,
+    };
+  } else if (value === undefined) {
+    return {
+      type: DataCubeOperationAdvancedValueType.VOID,
+    };
   }
-}
 
-function _buildDataCubeQueryFilter(
-  af: V1_AppliedFunction,
-  operator: string,
-  filterOperations: DataCubeQueryFilterOperation[],
-): DataCubeQuerySnapshotFilterCondition | undefined {
-  const filterOperation = filterOperations.find(
-    (op) => op.operator === operator,
-  );
-  return filterOperation?.buildConditionSnapshot(af);
+  return undefined;
 }
 
-function _buildDataCubeOperationValue(
-  type: string,
-  value: unknown,
-): DataCubeOperationValue {
-  return {
-    value: value,
-    type: type,
-  } satisfies DataCubeOperationValue;
+/**
+ * Processes filter conditions of form: column | operator | value, e.g.
+ * $x.Age > 5
+ * $x.Name == 'abc'
+ * $x.Name->startsWith('abc')
+ * $x.Age > $x.Age2
+ * $x.Name == $x.Name2
+ */
+export function _baseFilterCondition(
+  expression: V1_AppliedFunction,
+  columnGetter: (name: string) => DataCubeColumn,
+  func: string,
+) {
+  if (matchFunctionName(expression.function, func)) {
+    if (
+      expression.parameters.length !== 2 &&
+      expression.parameters.length !== 1
+    ) {
+      return undefined;
+    }
+
+    const column =
+      expression.parameters[0] instanceof V1_AppliedProperty
+        ? columnGetter(expression.parameters[0].property)
+        : undefined;
+    if (!column) {
+      return undefined;
+    }
+
+    const value = _filterConditionValue(
+      expression.parameters[1],
+      column,
+      columnGetter,
+    );
+    if (!value) {
+      return undefined;
+    }
+
+    return {
+      column,
+      value,
+    };
+  }
+  return undefined;
 }
 
-export function _buildConditionSnapshotProperty(
-  property: V1_AppliedProperty,
-  operator: DataCubeQueryFilterOperator,
-): DataCubeQuerySnapshotFilterCondition {
-  return {
-    name: property.property,
-    operator: operator,
-    type: property.class!, // TODO: fix this in engine (missing class in V1_AppliedProperty)
-  } as DataCubeQuerySnapshotFilterCondition;
+/**
+ * Processes filter conditions of form: column (case-insensitive) | operator | value (case-insensitive), e.g.
+ * $x.Name->toLower() == 'abc'->toLower()
+ * $x.Name->toLower() == $x.Name2->toLower()
+ */
+export function _caseSensitiveBaseFilterCondition(
+  expression: V1_AppliedFunction,
+  columnGetter: (name: string) => DataCubeColumn,
+  func: string,
+) {
+  if (matchFunctionName(expression.function, func)) {
+    if (expression.parameters.length !== 2) {
+      return undefined;
+    }
+
+    const param1 = expression.parameters[0];
+    if (
+      !(param1 instanceof V1_AppliedFunction) ||
+      !matchFunctionName(param1.function, DataCubeFunction.TO_LOWERCASE)
+    ) {
+      return undefined;
+    }
+    if (param1.parameters.length !== 1) {
+      return undefined;
+    }
+    const column =
+      param1.parameters[0] instanceof V1_AppliedProperty
+        ? columnGetter(param1.parameters[0].property)
+        : undefined;
+    if (!column) {
+      return undefined;
+    }
+
+    const param2 = expression.parameters[1];
+    if (
+      !(param2 instanceof V1_AppliedFunction) ||
+      !matchFunctionName(param2.function, DataCubeFunction.TO_LOWERCASE)
+    ) {
+      return undefined;
+    }
+    if (param2.parameters.length !== 1) {
+      return undefined;
+    }
+    const value = _filterConditionValue(
+      param2.parameters[0],
+      column,
+      columnGetter,
+    );
+
+    if (!value) {
+      return undefined;
+    }
+
+    return {
+      column,
+      value,
+    };
+  }
+  return undefined;
 }