@finos/legend-query-builder 0.0.1

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

@@ -0,0 +1,297 @@
+/**
+ * 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 {
+  LambdaFunctionInstanceValue,
+  AbstractPropertyExpression,
+  extractElementNameFromPath,
+  PrimitiveInstanceValue,
+  matchFunctionName,
+  VariableExpression,
+  FunctionExpression,
+  type SimpleFunctionExpression,
+} from '@finos/legend-graph';
+import {
+  assertTrue,
+  assertType,
+  guaranteeIsString,
+  guaranteeNonNullable,
+  guaranteeType,
+  UnsupportedOperationError,
+} from '@finos/legend-shared';
+import type { QueryBuilderAggregateColumnState } from '../aggregation/QueryBuilderAggregationState.js';
+import type { QueryBuilderPostFilterOperator } from './QueryBuilderPostFilterOperator.js';
+import {
+  type QueryBuilderPostFilterState,
+  getTDSColumnDerivedProperyFromType,
+  PostFilterConditionState,
+  QueryBuilderPostFilterTreeConditionNodeData,
+  QueryBuilderPostFilterTreeGroupNodeData,
+  TDS_COLUMN_GETTER,
+  getTypeFromDerivedProperty,
+} from './QueryBuilderPostFilterState.js';
+import {
+  type QueryBuilderProjectionColumnState,
+  QueryBuilderDerivationProjectionColumnState,
+} from '../QueryBuilderProjectionColumnState.js';
+import { toGroupOperation } from '../../../QueryBuilderGroupOperationHelper.js';
+import { QueryBuilderProjectionState } from '../QueryBuilderProjectionState.js';
+import type { QueryBuilderState } from '../../../QueryBuilderState.js';
+import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../../graphManager/QueryBuilderSupportedFunctions.js';
+
+const findProjectionColumnState = (
+  propertyExpression: AbstractPropertyExpression,
+  postFilterState: QueryBuilderPostFilterState,
+): QueryBuilderProjectionColumnState | QueryBuilderAggregateColumnState => {
+  const projectionState = postFilterState.projectionState;
+  const properyExpressionName = propertyExpression.func.name;
+  assertTrue(
+    Object.values(TDS_COLUMN_GETTER).includes(
+      properyExpressionName as TDS_COLUMN_GETTER,
+    ),
+    `Can't process TDS column expression: TDS column property '${properyExpressionName}' not supported. Supported types are ${Object.values(
+      TDS_COLUMN_GETTER,
+    ).join(',')}`,
+  );
+  const tdsColumnGetter = properyExpressionName as TDS_COLUMN_GETTER;
+  const columnNameExpression = propertyExpression.parametersValues[1];
+  const columnName = guaranteeIsString(
+    guaranteeType(
+      columnNameExpression,
+      PrimitiveInstanceValue,
+      'Can`t process TDS column expression: Column should be a primitive instance value',
+    ).values[0],
+    'Can`t process TDS column expression: Column should be a string primitive instance value',
+  );
+  const columnStates = [
+    ...projectionState.aggregationState.columns,
+    ...projectionState.columns,
+  ];
+  const columnState = guaranteeNonNullable(
+    columnStates.find((c) => c.columnName === columnName),
+  );
+  if (
+    tdsColumnGetter !== TDS_COLUMN_GETTER.IS_NULL &&
+    tdsColumnGetter !== TDS_COLUMN_GETTER.IS_NOT_NULL
+  ) {
+    if (columnState instanceof QueryBuilderDerivationProjectionColumnState) {
+      const type = getTypeFromDerivedProperty(
+        tdsColumnGetter,
+        postFilterState.projectionState.queryBuilderState.graphManagerState
+          .graph,
+      );
+      if (type) {
+        columnState.setReturnType(type);
+      }
+      return columnState;
+    }
+    const columnType = guaranteeNonNullable(columnState.getReturnType());
+    assertTrue(
+      (getTDSColumnDerivedProperyFromType(columnType) as string) ===
+        tdsColumnGetter,
+      `Can't process TDS column expression: expected column type ${getTDSColumnDerivedProperyFromType(
+        columnType,
+      )} (got ${tdsColumnGetter})`,
+    );
+  }
+  return columnState;
+};
+
+export const buildPostFilterConditionState = (
+  postFilterState: QueryBuilderPostFilterState,
+  expression: FunctionExpression,
+  operatorFunctionFullPath: string | undefined,
+  operator: QueryBuilderPostFilterOperator,
+): PostFilterConditionState | undefined => {
+  let postConditionState: PostFilterConditionState | undefined;
+  const tdsColumnGetter = operator.getTdsColumnGetter();
+  if (
+    tdsColumnGetter &&
+    expression instanceof AbstractPropertyExpression &&
+    expression.func.name === tdsColumnGetter
+  ) {
+    const columnState = findProjectionColumnState(expression, postFilterState);
+    postConditionState = new PostFilterConditionState(
+      postFilterState,
+      columnState,
+      undefined,
+      operator,
+    );
+    return postConditionState;
+  } else if (
+    operatorFunctionFullPath &&
+    matchFunctionName(expression.functionName, operatorFunctionFullPath)
+  ) {
+    assertTrue(
+      expression.parametersValues.length === 2,
+      `Can't process ${extractElementNameFromPath(
+        operatorFunctionFullPath,
+      )}() expression: ${extractElementNameFromPath(
+        operatorFunctionFullPath,
+      )}() expects '1 argument'`,
+    );
+
+    // get projection column
+    const tdsColumnPropertyExpression = guaranteeType(
+      expression.parametersValues[0],
+      AbstractPropertyExpression,
+      `Can't process ${extractElementNameFromPath(
+        operatorFunctionFullPath,
+      )}() expression: expects property expression in lambda body`,
+    );
+    const columnState = findProjectionColumnState(
+      tdsColumnPropertyExpression,
+      postFilterState,
+    );
+
+    // get operation value specification
+    const value = expression.parametersValues[1];
+    // create state
+    postConditionState = new PostFilterConditionState(
+      postFilterState,
+      columnState,
+      value,
+      operator,
+    );
+
+    //post checks
+    assertTrue(
+      operator.isCompatibleWithPostFilterColumn(postConditionState),
+      `Can't process ${extractElementNameFromPath(
+        operatorFunctionFullPath,
+      )}() expression: property is not compatible with post-filter operator`,
+    );
+    assertTrue(
+      operator.isCompatibleWithConditionValue(postConditionState),
+      `Operator '${operator.getLabel()}' not compatible with value specification ${value?.toString()}`,
+    );
+  }
+  return postConditionState;
+};
+
+const processPostFilterTree = (
+  expression: FunctionExpression,
+  postFilterState: QueryBuilderPostFilterState,
+  parentPostFilterNodeId: string | undefined,
+): void => {
+  const parentNode = parentPostFilterNodeId
+    ? postFilterState.getNode(parentPostFilterNodeId)
+    : undefined;
+  if (
+    matchFunctionName(expression.functionName, [
+      QUERY_BUILDER_SUPPORTED_FUNCTIONS.AND,
+      QUERY_BUILDER_SUPPORTED_FUNCTIONS.OR,
+    ])
+  ) {
+    const groupNode = new QueryBuilderPostFilterTreeGroupNodeData(
+      parentPostFilterNodeId,
+      toGroupOperation(expression.functionName),
+    );
+    postFilterState.nodes.set(groupNode.id, groupNode);
+    expression.parametersValues.forEach((postFilterExpression) =>
+      processPostFilterTree(
+        guaranteeType(
+          postFilterExpression,
+          FunctionExpression,
+          `Can't process post-filter group expression: each child expression must be a function expression`,
+        ),
+        postFilterState,
+        groupNode.id,
+      ),
+    );
+    postFilterState.addNodeFromNode(groupNode, parentNode);
+  } else {
+    for (const operator of postFilterState.operators) {
+      // NOTE: this allow plugin author to either return `undefined`
+      const postFilterConditionState = operator.buildPostFilterConditionState(
+        postFilterState,
+        expression,
+      );
+      if (postFilterConditionState) {
+        postFilterState.addNodeFromNode(
+          new QueryBuilderPostFilterTreeConditionNodeData(
+            undefined,
+            postFilterConditionState,
+          ),
+          parentNode,
+        );
+        return;
+      }
+    }
+    throw new UnsupportedOperationError(
+      `Can't process post-filter expression: no compatible post-filter operator processer available from plugins`,
+    );
+  }
+};
+
+export const processTDSPostFilterExpression = (
+  expression: SimpleFunctionExpression,
+  queryBuilderState: QueryBuilderState,
+): void => {
+  if (
+    queryBuilderState.fetchStructureState.implementation instanceof
+    QueryBuilderProjectionState
+  ) {
+    const projectionState =
+      queryBuilderState.fetchStructureState.implementation;
+    const postFilterState = projectionState.postFilterState;
+    const fetchStructureState = projectionState.fetchStructureState;
+    const postFilterLambda = expression.parametersValues[1];
+    assertType(
+      postFilterLambda,
+      LambdaFunctionInstanceValue,
+      `Can't process post-filter expression: expects argument #1 to be a lambda function`,
+    );
+
+    assertType(
+      fetchStructureState.implementation,
+      QueryBuilderProjectionState,
+      `Can't process post-filter lambda: post-filter lambda must use projection fetch structure`,
+    );
+    assertTrue(
+      Boolean(projectionState.columns.length),
+      `Can't process post-filter lambda: post-filter lambda must have at least one projection column `,
+    );
+    const lambdaFunc = guaranteeNonNullable(
+      postFilterLambda.values[0],
+      `Can't process post-filter lambda: post-filter lambda function is missing`,
+    );
+    assertTrue(
+      lambdaFunc.expressionSequence.length === 1,
+      `Can't process post-filter lambda: only support post-filter lambda body with 1 expression`,
+    );
+    const rootExpression = guaranteeType(
+      lambdaFunc.expressionSequence[0],
+      FunctionExpression,
+      `Can't process post-filter lambda: only support post-filter lambda body of type 'FunctionExpression'`,
+    );
+    assertTrue(
+      lambdaFunc.functionType.parameters.length === 1,
+      `Can't process post-filter lambda: only support post-filter lambda with 1 parameter`,
+    );
+    postFilterState.setLambdaParameterName(
+      guaranteeType(
+        lambdaFunc.functionType.parameters[0],
+        VariableExpression,
+        `Can't process post-filter lambda: only support filter() lambda with 1 parameter of type 'VariableExpression'`,
+      ).name,
+    );
+    processPostFilterTree(rootExpression, postFilterState, undefined);
+
+    projectionState.setShowPostFilterPanel(true);
+    postFilterState.simplifyTree();
+  }
+};

package/src/stores/fetch-structure/projection/post-filter/QueryBuilderPostFilterValueSpecificationBuilder.ts

@@ -0,0 +1,121 @@
+/**
+ * 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 {
+  extractElementNameFromPath,
+  SimpleFunctionExpression,
+  TYPICAL_MULTIPLICITY_TYPE,
+  type LambdaFunction,
+  type ValueSpecification,
+} from '@finos/legend-graph';
+import { guaranteeNonNullable, isNonNullable } from '@finos/legend-shared';
+import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../../graphManager/QueryBuilderSupportedFunctions.js';
+import { fromGroupOperation } from '../../../QueryBuilderGroupOperationHelper.js';
+import { buildGenericLambdaFunctionInstanceValue } from '../../../QueryBuilderValueSpecificationHelper.js';
+import {
+  QueryBuilderPostFilterTreeConditionNodeData,
+  QueryBuilderPostFilterTreeGroupNodeData,
+  type QueryBuilderPostFilterTreeNodeData,
+  type QueryBuilderPostFilterState,
+} from './QueryBuilderPostFilterState.js';
+
+const buildPostFilterExpression = (
+  filterState: QueryBuilderPostFilterState,
+  node: QueryBuilderPostFilterTreeNodeData,
+): ValueSpecification | undefined => {
+  if (node instanceof QueryBuilderPostFilterTreeConditionNodeData) {
+    return node.condition.operator.buildPostFilterConditionExpression(
+      node.condition,
+    );
+  } else if (node instanceof QueryBuilderPostFilterTreeGroupNodeData) {
+    const multiplicityOne =
+      filterState.projectionState.queryBuilderState.graphManagerState.graph.getTypicalMultiplicity(
+        TYPICAL_MULTIPLICITY_TYPE.ONE,
+      );
+    const func = new SimpleFunctionExpression(
+      extractElementNameFromPath(fromGroupOperation(node.groupOperation)),
+      multiplicityOne,
+    );
+    const clauses = node.childrenIds
+      .map((e) => filterState.nodes.get(e))
+      .filter(isNonNullable)
+      .map((e) => buildPostFilterExpression(filterState, e))
+      .filter(isNonNullable);
+    /**
+     * NOTE: Due to a limitation (or perhaps design decision) in the engine, group operations
+     * like and/or do not take more than 2 parameters, as such, if we have more than 2, we need
+     * to create a chain of this operation to accomondate.
+     *
+     * This means that in the read direction, we might need to flatten the chains down to group with
+     * multiple clauses. This means user's intended grouping will not be kept.
+     */
+    if (clauses.length > 2) {
+      const firstClause = clauses[0] as ValueSpecification;
+      let currentClause: ValueSpecification = clauses[
+        clauses.length - 1
+      ] as ValueSpecification;
+      for (let i = clauses.length - 2; i > 0; --i) {
+        const clause1 = clauses[i] as ValueSpecification;
+        const clause2 = currentClause;
+        const groupClause = new SimpleFunctionExpression(
+          extractElementNameFromPath(fromGroupOperation(node.groupOperation)),
+          multiplicityOne,
+        );
+        groupClause.parametersValues = [clause1, clause2];
+        currentClause = groupClause;
+      }
+      func.parametersValues = [firstClause, currentClause];
+    } else {
+      func.parametersValues = clauses;
+    }
+    return func.parametersValues.length ? func : undefined;
+  }
+  return undefined;
+};
+
+export const appendPostFilter = (
+  postFilterState: QueryBuilderPostFilterState,
+  lambda: LambdaFunction,
+): LambdaFunction => {
+  const postFilterConditionExpressions = postFilterState.rootIds
+    .map((e) => guaranteeNonNullable(postFilterState.nodes.get(e)))
+    .map((e) => buildPostFilterExpression(postFilterState, e))
+    .filter(isNonNullable);
+  if (
+    !postFilterConditionExpressions.length ||
+    lambda.expressionSequence.length !== 1
+  ) {
+    return lambda;
+  }
+  const multiplicityOne =
+    postFilterState.projectionState.queryBuilderState.graphManagerState.graph.getTypicalMultiplicity(
+      TYPICAL_MULTIPLICITY_TYPE.ONE,
+    );
+  const filterLambda = buildGenericLambdaFunctionInstanceValue(
+    postFilterState.lambdaParameterName,
+    postFilterConditionExpressions,
+    postFilterState.projectionState.queryBuilderState.graphManagerState.graph,
+  );
+  // main filter expression
+  const filterExpression = new SimpleFunctionExpression(
+    extractElementNameFromPath(QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_FILTER),
+    multiplicityOne,
+  );
+  const currentExpression = guaranteeNonNullable(lambda.expressionSequence[0]);
+  filterExpression.parametersValues = [currentExpression, filterLambda];
+  lambda.expressionSequence[0] = filterExpression;
+  return lambda;
+};

package/src/stores/fetch-structure/projection/post-filter/operators/QueryBuilderPostFilterOperatorHelper.ts

@@ -0,0 +1,129 @@
+/**
+ * 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 Multiplicity,
+  type FunctionExpression,
+  AbstractPropertyExpression,
+  extractElementNameFromPath,
+  GenericType,
+  GenericTypeExplicitReference,
+  PrimitiveInstanceValue,
+  PRIMITIVE_TYPE,
+  SimpleFunctionExpression,
+  TYPICAL_MULTIPLICITY_TYPE,
+  VariableExpression,
+  getAllClassDerivedProperties,
+  CORE_PURE_PATH,
+} from '@finos/legend-graph';
+import {
+  guaranteeNonNullable,
+  UnsupportedOperationError,
+} from '@finos/legend-shared';
+import { QueryBuilderAggregateColumnState } from '../../aggregation/QueryBuilderAggregationState.js';
+import type { QueryBuilderPostFilterOperator } from '../QueryBuilderPostFilterOperator.js';
+import {
+  type PostFilterConditionState,
+  type TDS_COLUMN_GETTER,
+  getTDSColumnDerivedProperyFromType,
+} from '../QueryBuilderPostFilterState.js';
+import {
+  type QueryBuilderProjectionColumnState,
+  QueryBuilderSimpleProjectionColumnState,
+} from '../../QueryBuilderProjectionColumnState.js';
+
+export const getColumnMultiplicity = (
+  columnState:
+    | QueryBuilderProjectionColumnState
+    | QueryBuilderAggregateColumnState,
+): Multiplicity => {
+  if (columnState instanceof QueryBuilderAggregateColumnState) {
+    return columnState.aggregationState.projectionState.queryBuilderState.graphManagerState.graph.getTypicalMultiplicity(
+      TYPICAL_MULTIPLICITY_TYPE.ONE,
+    );
+  } else if (columnState instanceof QueryBuilderSimpleProjectionColumnState) {
+    return columnState.propertyExpressionState.propertyExpression.func
+      .multiplicity;
+  }
+  throw new UnsupportedOperationError(
+    `Can't get multiplicity for column`,
+    columnState,
+  );
+};
+
+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.projectionState.queryBuilderState
+      .graphManagerState.graph;
+  const multiplicityOne = graph.getTypicalMultiplicity(
+    TYPICAL_MULTIPLICITY_TYPE.ONE,
+  );
+  const typeString = graph.getPrimitiveType(PRIMITIVE_TYPE.STRING);
+  // property expression
+  const colState = filterConditionState.columnState;
+  const tdsPropertyExpression = new AbstractPropertyExpression(
+    '',
+    multiplicityOne,
+  );
+  let tdsDerivedPropertyName: TDS_COLUMN_GETTER;
+  const correspondingTdsDerivedProperty = operator.getTdsColumnGetter();
+  if (correspondingTdsDerivedProperty) {
+    tdsDerivedPropertyName = correspondingTdsDerivedProperty;
+  } else {
+    const type = guaranteeNonNullable(colState.getReturnType());
+    tdsDerivedPropertyName = getTDSColumnDerivedProperyFromType(type);
+  }
+  tdsPropertyExpression.func = guaranteeNonNullable(
+    getAllClassDerivedProperties(graph.getClass(CORE_PURE_PATH.TDS_ROW)).find(
+      (p) => p.name === tdsDerivedPropertyName,
+    ),
+  );
+  const variableName = new VariableExpression(
+    filterConditionState.postFilterState.lambdaParameterName,
+    multiplicityOne,
+  );
+  const colInstanceValue = new PrimitiveInstanceValue(
+    GenericTypeExplicitReference.create(new GenericType(typeString)),
+    multiplicityOne,
+  );
+  colInstanceValue.values = [colState.columnName];
+  tdsPropertyExpression.parametersValues = [variableName, colInstanceValue];
+
+  if (operatorFunctionFullPath) {
+    const expression = new SimpleFunctionExpression(
+      extractElementNameFromPath(operatorFunctionFullPath),
+      multiplicityOne,
+    );
+    expression.parametersValues.push(tdsPropertyExpression);
+    if (filterConditionState.value) {
+      expression.parametersValues.push(filterConditionState.value);
+    }
+    return expression;
+  } else {
+    return tdsPropertyExpression;
+  }
+};

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

@@ -0,0 +1,140 @@
+/**
+ * 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 SimpleFunctionExpression,
+  type Type,
+  type ValueSpecification,
+  type FunctionExpression,
+  PRIMITIVE_TYPE,
+  buildPrimitiveInstanceValue,
+} from '@finos/legend-graph';
+import {
+  guaranteeNonNullable,
+  UnsupportedOperationError,
+} from '@finos/legend-shared';
+import { QueryBuilderPostFilterOperator } from '../QueryBuilderPostFilterOperator.js';
+import { buildPostFilterConditionState } from '../QueryBuilderPostFilterStateBuilder.js';
+import type {
+  PostFilterConditionState,
+  QueryBuilderPostFilterState,
+} from '../QueryBuilderPostFilterState.js';
+import {
+  buildNotExpression,
+  generateDefaultValueForPrimitiveType,
+  getNonCollectionValueSpecificationType,
+  unwrapNotExpression,
+} from '../../../../QueryBuilderValueSpecificationHelper.js';
+import { buildPostFilterConditionExpression } from './QueryBuilderPostFilterOperatorHelper.js';
+import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../../../graphManager/QueryBuilderSupportedFunctions.js';
+
+export class QueryBuilderPostFilterOperator_Contain extends QueryBuilderPostFilterOperator {
+  getLabel(): string {
+    return 'contains';
+  }
+
+  isCompatibleWithType(type: Type): boolean {
+    if (type.path === PRIMITIVE_TYPE.STRING) {
+      return true;
+    }
+    return false;
+  }
+
+  isCompatibleWithConditionValue(
+    postFilterConditionState: PostFilterConditionState,
+  ): boolean {
+    const type = postFilterConditionState.value
+      ? getNonCollectionValueSpecificationType(postFilterConditionState.value)
+      : undefined;
+    return PRIMITIVE_TYPE.STRING === type?.path;
+  }
+
+  getDefaultFilterConditionValue(
+    postFilterConditionState: PostFilterConditionState,
+  ): ValueSpecification {
+    const propertyType = guaranteeNonNullable(
+      postFilterConditionState.columnState.getReturnType(),
+    );
+    switch (propertyType.path) {
+      case PRIMITIVE_TYPE.STRING: {
+        return buildPrimitiveInstanceValue(
+          postFilterConditionState.postFilterState.projectionState
+            .queryBuilderState.graphManagerState.graph,
+          propertyType.path,
+          generateDefaultValueForPrimitiveType(propertyType.path),
+        );
+      }
+      default:
+        throw new UnsupportedOperationError(
+          `Can't get default value for post-filter operator '${this.getLabel()}' when the LHS property is of type '${
+            propertyType.path
+          }'`,
+        );
+    }
+  }
+
+  buildPostFilterConditionExpression(
+    postFilterConditionState: PostFilterConditionState,
+  ): ValueSpecification | undefined {
+    return buildPostFilterConditionExpression(
+      postFilterConditionState,
+      this,
+      QUERY_BUILDER_SUPPORTED_FUNCTIONS.CONTAINS,
+    );
+  }
+
+  buildPostFilterConditionState(
+    postFilterState: QueryBuilderPostFilterState,
+    expression: FunctionExpression,
+  ): PostFilterConditionState | undefined {
+    return buildPostFilterConditionState(
+      postFilterState,
+      expression,
+      QUERY_BUILDER_SUPPORTED_FUNCTIONS.CONTAINS,
+      this,
+    );
+  }
+}
+
+export class QueryBuilderPostFilterOperator_NotContain extends QueryBuilderPostFilterOperator_Contain {
+  override getLabel(): string {
+    return `doesn't contain`;
+  }
+  override buildPostFilterConditionExpression(
+    postFilterConditionState: PostFilterConditionState,
+  ): ValueSpecification | undefined {
+    const expression = super.buildPostFilterConditionExpression(
+      postFilterConditionState,
+    );
+    return expression
+      ? buildNotExpression(
+          postFilterConditionState.postFilterState.projectionState
+            .queryBuilderState.graphManagerState.graph,
+          expression,
+        )
+      : undefined;
+  }
+
+  override buildPostFilterConditionState(
+    postFilterState: QueryBuilderPostFilterState,
+    expression: SimpleFunctionExpression,
+  ): PostFilterConditionState | undefined {
+    const innerExpression = unwrapNotExpression(expression);
+    return innerExpression
+      ? super.buildPostFilterConditionState(postFilterState, innerExpression)
+      : undefined;
+  }
+}