@finos/legend-query-builder 4.14.44 → 4.14.46

package/src/components/fetch-structure/QueryBuilderTDSPanel.tsx

@@ -41,6 +41,8 @@ import {
   FunctionIcon,
   CogIcon,
   InfoCircleIcon,
+  BasePopover,
+  InputWithInlineValidation,
 } from '@finos/legend-art';
 import {
   type QueryBuilderExplorerTreeDragSource,
@@ -116,6 +118,7 @@ import {
   QueryBuilderPropertyInfoTooltip,
 } from '../shared/QueryBuilderPropertyInfoTooltip.js';
 import { getNameOfValueSpecification } from '../shared/QueryBuilderVariableSelector.js';
+import { QueryBuilderAggregateOperator_Percentile } from '../../stores/fetch-structure/tds/aggregation/operators/QueryBuilderAggregateOperator_Percentile.js';
 
 const QueryBuilderProjectionColumnContextMenu = observer(
   forwardRef<
@@ -689,6 +692,52 @@ const QueryBuilderProjectionColumnEditor = observer(
       }),
       [handleDrop],
     );
+    const percentileButtonRef = useRef<HTMLButtonElement>(null);
+    const percentileInputRef = useRef<HTMLInputElement>(null);
+    const [isPercentileOpen, setIsPercentileOpen] = useState(false);
+    const [percentileValue, setPercentileValue] = useState(
+      aggregateColumnState &&
+        aggregateColumnState.operator instanceof
+          QueryBuilderAggregateOperator_Percentile &&
+        aggregateColumnState.operator.percentile !== undefined
+        ? (aggregateColumnState.operator.percentile * 100).toString()
+        : '',
+    );
+    const [acending, setAcending] = useState(
+      aggregateColumnState &&
+        aggregateColumnState.operator instanceof
+          QueryBuilderAggregateOperator_Percentile
+        ? aggregateColumnState.operator.acending
+        : undefined,
+    );
+    const [continuous, setContinuous] = useState(
+      aggregateColumnState &&
+        aggregateColumnState.operator instanceof
+          QueryBuilderAggregateOperator_Percentile
+        ? aggregateColumnState.operator.continuous
+        : undefined,
+    );
+    const percentileOptions = ['true', 'false'].map((op) => ({
+      label: op,
+      value: op,
+    }));
+    const getPercentileDisplayValue = (): string => {
+      if (percentileValue === '') {
+        return '...';
+      }
+      if (acending === undefined || continuous === undefined) {
+        return `${Number(percentileValue)}`;
+      }
+      return `${Number(percentileValue)}, ${acending}, ${continuous}`;
+    };
+    const setPercentileArguments = (): void => {
+      setIsPercentileOpen(!isPercentileOpen);
+    };
+    const onPercentileValueChange: React.ChangeEventHandler<
+      HTMLInputElement
+    > = (event) => {
+      setPercentileValue(event.target.value);
+    };
 
     return (
       <PanelDnDEntry
@@ -817,12 +866,167 @@ const QueryBuilderProjectionColumnEditor = observer(
             <div className="query-builder__projection__column__aggregate">
               <div className="query-builder__projection__column__aggregate__operator">
                 {aggregateColumnState && (
-                  <div className="query-builder__projection__column__aggregate__operator__label">
-                    {aggregateColumnState.operator.getLabel(
-                      projectionColumnState,
-                    )}
+                  <div className="query-builder__projection__column__aggregate__operator">
+                    <div className="query-builder__projection__column__aggregate__operator__label">
+                      {aggregateColumnState.operator.getLabel(
+                        projectionColumnState,
+                      )}
+                      {aggregateColumnState.operator instanceof
+                        QueryBuilderAggregateOperator_Percentile && (
+                        <button
+                          className="query-builder__projection__column__aggregate__operator__percentile__badge"
+                          ref={percentileButtonRef}
+                          onClick={setPercentileArguments}
+                          title="Set Percentile Argument(s)..."
+                        >
+                          {getPercentileDisplayValue()}
+                        </button>
+                      )}
+                    </div>
                   </div>
                 )}
+                {aggregateColumnState && isPercentileOpen && (
+                  <BasePopover
+                    open={isPercentileOpen}
+                    PaperProps={{
+                      classes: {
+                        root: 'query-builder__projection__column__aggregate__operator__percentile__container__root',
+                      },
+                    }}
+                    className={clsx(
+                      'query-builder__projection__column__aggregate__operator__percentile__container',
+                    )}
+                    anchorEl={percentileButtonRef.current}
+                    onClose={() => {
+                      const percentileOperator =
+                        aggregateColumnState.operator as QueryBuilderAggregateOperator_Percentile;
+                      if (percentileValue === '') {
+                        percentileOperator.setPercentile(undefined);
+                      } else {
+                        percentileOperator.setPercentile(
+                          Number(percentileValue) / 100,
+                        );
+                      }
+                      if (acending !== undefined && continuous !== undefined) {
+                        percentileOperator.setAcending(acending);
+                        percentileOperator.setContinuous(continuous);
+                      }
+                      setIsPercentileOpen(false);
+                    }}
+                    anchorOrigin={{
+                      vertical: 'bottom',
+                      horizontal: 'left',
+                    }}
+                    transformOrigin={{
+                      vertical: 'top',
+                      horizontal: 'center',
+                    }}
+                  >
+                    <div
+                      data-testid={
+                        QUERY_BUILDER_TEST_ID.QUERY_BUILDER_PERCENTILE_PANEL
+                      }
+                      className=""
+                    >
+                      <div className="query-builder__projection__column__aggregate__operator__percentile__argument-combo">
+                        <div className="query-builder__projection__column__aggregate__operator__percentile__argument-combo__label">
+                          Percentile
+                          <br />
+                          (0-100)
+                        </div>
+                        <div
+                          className={clsx(
+                            'query-builder__projection__column__aggregate__operator__percentile__argument-combo__value',
+                          )}
+                        >
+                          <InputWithInlineValidation
+                            ref={percentileInputRef}
+                            className={clsx(
+                              'query-builder__projection__column__aggregate__operator__percentile__input input--dark',
+                            )}
+                            type="text"
+                            inputMode="numeric"
+                            onChange={onPercentileValueChange}
+                            value={percentileValue}
+                            error={
+                              percentileValue && Number(percentileValue) > 100
+                                ? `Invalid aggregation agruement for ${aggregateColumnState.columnName}`
+                                : undefined
+                            }
+                          />
+                        </div>
+                      </div>
+                      <div className="query-builder__projection__column__aggregate__operator__percentile__argument-combo">
+                        <div className="query-builder__projection__column__aggregate__operator__percentile__argument-combo__label">
+                          Acending
+                        </div>
+                        <CustomSelectorInput
+                          className="query-loader__results__sort-by__selector query-builder__projection__column__aggregate__operator__percentile__argument-combo__value"
+                          options={percentileOptions}
+                          onChange={(option: {
+                            label: string;
+                            value: string;
+                          }) => {
+                            setAcending(option.value === 'true' ? true : false);
+                          }}
+                          value={{
+                            label:
+                              acending === undefined
+                                ? ''
+                                : acending
+                                  ? 'true'
+                                  : 'false',
+                            value:
+                              acending === undefined
+                                ? ''
+                                : acending
+                                  ? 'true'
+                                  : 'false',
+                          }}
+                          darkMode={
+                            !applicationStore.layoutService
+                              .TEMPORARY__isLightColorThemeEnabled
+                          }
+                        />
+                      </div>
+                      <div className="query-builder__projection__column__aggregate__operator__percentile__argument-combo">
+                        <div className="query-builder__projection__column__aggregate__operator__percentile__argument-combo__label">
+                          Continous
+                        </div>
+                        <CustomSelectorInput
+                          className="query-loader__results__sort-by__selector query-builder__projection__column__aggregate__operator__percentile__argument-combo__value"
+                          options={percentileOptions}
+                          onChange={(option: {
+                            label: string;
+                            value: string;
+                          }) =>
+                            setContinuous(
+                              option.value === 'true' ? true : false,
+                            )
+                          }
+                          value={{
+                            label:
+                              continuous === undefined
+                                ? ''
+                                : continuous
+                                  ? 'true'
+                                  : 'false',
+                            value:
+                              continuous === undefined
+                                ? ''
+                                : continuous
+                                  ? 'true'
+                                  : 'false',
+                          }}
+                          darkMode={
+                            !applicationStore.layoutService
+                              .TEMPORARY__isLightColorThemeEnabled
+                          }
+                        />
+                      </div>
+                    </div>
+                  </BasePopover>
+                )}
                 {isCalendarEnabled &&
                   aggregateColumnState &&
                   aggregateCalendarFunctions.length > 0 && (

package/src/graph/QueryBuilderMetaModelConst.ts

@@ -163,6 +163,7 @@ export enum QUERY_BUILDER_SUPPORTED_FUNCTIONS {
   FROM = 'meta::pure::mapping::from',
   CHECKED = 'meta::pure::dataQuality::checked',
   MERGERUNTIMES = 'meta::pure::runtime::mergeRuntimes',
+  PERCENTILE = 'meta::pure::functions::math::percentile',
 
   // TOTDS
   TABLE_TO_TDS = 'meta::pure::tds::tableToTDS',

package/src/index.ts

@@ -30,7 +30,7 @@ export { QueryBuilderNavigationBlocker } from './components/QueryBuilderNavigati
 export { QueryBuilder } from './components/QueryBuilder.js';
 export { QUERY_BUILDER_COMPONENT_ELEMENT_ID } from './components/QueryBuilderComponentElement.js';
 export {
-  type QuerySDLC,
+  type QueryableSourceInfo as QuerySDLC,
   QueryBuilderState,
 } from './stores/QueryBuilderState.js';
 export {

package/src/stores/QueryBuilderState.ts

@@ -111,9 +111,9 @@ import { QUERY_BUILDER_EVENT } from '../__lib__/QueryBuilderEvent.js';
 import { QueryBuilderChangeHistoryState } from './QueryBuilderChangeHistoryState.js';
 import { type QueryBuilderWorkflowState } from './query-workflow/QueryBuilderWorkFlowState.js';
 
-export interface QuerySDLC {}
+export interface QueryableSourceInfo {}
 
-export type QueryStateInfo = QuerySDLC & {
+export type QueryableClassMappingRuntimeInfo = QueryableSourceInfo & {
   class: string;
   mapping: string;
   runtime: string;
@@ -169,7 +169,7 @@ export abstract class QueryBuilderState implements CommandRegistrar {
   // NOTE: This property contains information about workflow used
   // to create this state. This should only be used to add additional
   // information to query builder analytics.
-  sourceInfo?: QuerySDLC | undefined;
+  sourceInfo?: QueryableSourceInfo | undefined;
 
   // NOTE: this makes it so that we need to import components in stores code,
   // we probably want to refactor to an extension mechanism
@@ -180,7 +180,7 @@ export abstract class QueryBuilderState implements CommandRegistrar {
     graphManagerState: GraphManagerState,
     workflowState: QueryBuilderWorkflowState,
     config: QueryBuilderConfig | undefined,
-    sourceInfo?: QuerySDLC | undefined,
+    sourceInfo?: QueryableSourceInfo | undefined,
   ) {
     makeObservable(this, {
       explorerState: observable,
@@ -341,7 +341,7 @@ export abstract class QueryBuilderState implements CommandRegistrar {
    * Gets information about the current queryBuilderState.
    * This information can be used as a part of analytics
    */
-  getStateInfo(): QueryStateInfo | undefined {
+  getStateInfo(): QueryableClassMappingRuntimeInfo | undefined {
     if (this.sourceInfo) {
       const classPath = this.class?.path;
       const mappingPath = this.executionContextState.mapping?.path;

package/src/stores/QueryBuilderStateHashUtils.ts

@@ -32,6 +32,7 @@ export enum QUERY_BUILDER_STATE_HASH_STRUCTURE {
   AGGREGATE_OPERATOR_STD_DEV_SAMPLE = 'AGGREGATE_OPERATOR_STD_DEV_SAMPLE',
   AGGREGATE_OPERATOR_SUM = 'AGGREGATE_OPERATOR_SUM',
   AGGREGATE_COLUMN_STATE = 'AGGREGATE_COLUMN_STATE',
+  AGGREGATE_OPERATOR_PERCENTILE = 'AGGREGATE_OPERATOR_PERCENTILE',
   AGGREGATION_STATE = 'AGGREGATION_STATE',
   SIMPLE_PROJECTION_COLUMN_STATE = 'SIMPLE_PROJECTION_COLUMN_STATE',
   PROPERTY_EXPRESSION_STATE = 'PROPERTY_EXPRESSION_STATE',

package/src/stores/fetch-structure/tds/QueryBuilderTDSState.ts

@@ -139,6 +139,7 @@ export class QueryBuilderTDSState
     super(queryBuilderState, fetchStructureState);
 
     makeObservable(this, {
+      aggregationState: observable,
       projectionColumns: observable,
       isConvertDerivationProjectionObjects: observable,
       showPostFilterPanel: observable,
@@ -343,6 +344,10 @@ export class QueryBuilderTDSState
       }
     });
 
+    this.aggregationState.allValidationIssues.forEach((issue) =>
+      validationIssues.push(issue),
+    );
+
     return validationIssues;
   }
 

package/src/stores/fetch-structure/tds/aggregation/QueryBuilderAggregateOperator.ts

@@ -35,6 +35,8 @@ export abstract class QueryBuilderAggregateOperator implements Hashable {
 
   constructor() {
     makeObservable(this, {
+      getOperator: computed,
+      allValidationIssues: computed,
       hashCode: computed,
     });
   }
@@ -84,5 +86,13 @@ export abstract class QueryBuilderAggregateOperator implements Hashable {
     return aggregateColumnState.projectionColumnState.getColumnType();
   }
 
+  get getOperator(): QueryBuilderAggregateOperator {
+    return this;
+  }
+
+  get allValidationIssues(): string[] {
+    return [];
+  }
+
   abstract get hashCode(): string;
 }

package/src/stores/fetch-structure/tds/aggregation/QueryBuilderAggregateOperatorLoader.ts

@@ -25,6 +25,7 @@ import { QueryBuilderAggregateOperator_Min } from './operators/QueryBuilderAggre
 import { QueryBuilderAggregateOperator_Max } from './operators/QueryBuilderAggregateOperator_Max.js';
 import { QueryBuilderAggregateOperator_JoinString } from './operators/QueryBuilderAggregateOperator_JoinString.js';
 import type { QueryBuilderAggregateOperator } from './QueryBuilderAggregateOperator.js';
+import { QueryBuilderAggregateOperator_Percentile } from './operators/QueryBuilderAggregateOperator_Percentile.js';
 
 export const getQueryBuilderCoreAggregrationOperators =
   (): QueryBuilderAggregateOperator[] => [
@@ -35,6 +36,7 @@ export const getQueryBuilderCoreAggregrationOperators =
     new QueryBuilderAggregateOperator_Average(),
     new QueryBuilderAggregateOperator_Min(),
     new QueryBuilderAggregateOperator_Max(),
+    new QueryBuilderAggregateOperator_Percentile(),
     new QueryBuilderAggregateOperator_StdDev_Population(),
     new QueryBuilderAggregateOperator_StdDev_Sample(),
     new QueryBuilderAggregateOperator_JoinString(),

package/src/stores/fetch-structure/tds/aggregation/QueryBuilderAggregationState.ts

@@ -136,6 +136,8 @@ export class QueryBuilderAggregationState implements Hashable {
       addColumn: action,
       changeColumnAggregateOperator: action,
       disableCalendar: action,
+
+      allValidationIssues: computed,
       hashCode: computed,
     });
 
@@ -179,7 +181,7 @@ export class QueryBuilderAggregationState implements Hashable {
             `${colName} (${val.getLabel(projectionColumnState)})`,
           );
         }
-        aggregateColumnState.setOperator(val);
+        aggregateColumnState.setOperator(val.getOperator);
       } else {
         if (!hideOperatorInColumnName) {
           projectionColumnState.setColumnName(
@@ -189,9 +191,9 @@ export class QueryBuilderAggregationState implements Hashable {
         const newAggregateColumnState = new QueryBuilderAggregateColumnState(
           this,
           projectionColumnState,
-          val,
+          val.getOperator,
         );
-        newAggregateColumnState.setOperator(val);
+        newAggregateColumnState.setOperator(val.getOperator);
         this.addColumn(newAggregateColumnState);
 
         // automatically move the column to the end
@@ -233,6 +235,10 @@ export class QueryBuilderAggregationState implements Hashable {
     });
   }
 
+  get allValidationIssues(): string[] {
+    return this.columns.map((col) => col.operator.allValidationIssues).flat();
+  }
+
   get hashCode(): string {
     return hashArray([
       QUERY_BUILDER_STATE_HASH_STRUCTURE.AGGREGATION_STATE,

package/src/stores/fetch-structure/tds/aggregation/operators/QueryBuilderAggregateOperatorValueSpecificationBuilder.ts

@@ -97,7 +97,6 @@ export const buildAggregateColumnState = (
       )}() expression: property is not compatible with operator`,
     );
     aggregateColumnState.setOperator(operator);
-
     return aggregateColumnState;
   }
 

package/src/stores/fetch-structure/tds/aggregation/operators/QueryBuilderAggregateOperator_Percentile.ts

@@ -0,0 +1,241 @@
+/**
+ * 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 {
+  matchFunctionName,
+  PRIMITIVE_TYPE,
+  type ValueSpecification,
+  SimpleFunctionExpression,
+  VariableExpression,
+  type PureModel,
+  type AbstractPropertyExpression,
+  GenericType,
+  GenericTypeExplicitReference,
+  Multiplicity,
+  PrimitiveInstanceValue,
+  PrimitiveType,
+  extractElementNameFromPath,
+} from '@finos/legend-graph';
+import { QueryBuilderAggregateColumnState } from '../QueryBuilderAggregationState.js';
+import { QueryBuilderAggregateOperator } from '../QueryBuilderAggregateOperator.js';
+import {
+  type QueryBuilderProjectionColumnState,
+  QueryBuilderSimpleProjectionColumnState,
+} from '../../projection/QueryBuilderProjectionColumnState.js';
+import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../../../graph/QueryBuilderMetaModelConst.js';
+import {
+  type Hashable,
+  hashArray,
+  assertTrue,
+  guaranteeType,
+} from '@finos/legend-shared';
+import { QUERY_BUILDER_STATE_HASH_STRUCTURE } from '../../../../QueryBuilderStateHashUtils.js';
+import { action, makeObservable, observable } from 'mobx';
+
+export class QueryBuilderAggregateOperator_Percentile
+  extends QueryBuilderAggregateOperator
+  implements Hashable
+{
+  percentile: number | undefined;
+  acending: boolean | undefined;
+  continuous: boolean | undefined;
+
+  constructor() {
+    super();
+    makeObservable(this, {
+      percentile: observable,
+      acending: observable,
+      continuous: observable,
+      setPercentile: action,
+      setAcending: action,
+      setContinuous: action,
+    });
+  }
+
+  setPercentile(val: number | undefined) {
+    this.percentile = val;
+  }
+
+  setAcending(val: boolean | undefined) {
+    this.acending = val;
+  }
+
+  setContinuous(val: boolean | undefined) {
+    this.continuous = val;
+  }
+
+  getLabel(projectionColumnState: QueryBuilderProjectionColumnState): string {
+    return 'percentile';
+  }
+
+  isCompatibleWithColumn(
+    projectionColumnState: QueryBuilderProjectionColumnState,
+  ): boolean {
+    if (
+      projectionColumnState instanceof QueryBuilderSimpleProjectionColumnState
+    ) {
+      const propertyType =
+        projectionColumnState.propertyExpressionState.propertyExpression.func
+          .value.genericType.value.rawType;
+      return (
+        [
+          PRIMITIVE_TYPE.NUMBER,
+          PRIMITIVE_TYPE.INTEGER,
+          PRIMITIVE_TYPE.DECIMAL,
+          PRIMITIVE_TYPE.FLOAT,
+        ] as string[]
+      ).includes(propertyType.path);
+    }
+    return true;
+  }
+
+  buildAggregateExpression(
+    propertyExpression: AbstractPropertyExpression | undefined,
+    variableName: string,
+    graph: PureModel,
+  ): ValueSpecification {
+    const percentileValue = this.percentile ?? 0;
+    const expression = new SimpleFunctionExpression(
+      extractElementNameFromPath(QUERY_BUILDER_SUPPORTED_FUNCTIONS.PERCENTILE),
+    );
+    const percentile = new PrimitiveInstanceValue(
+      GenericTypeExplicitReference.create(
+        new GenericType(PrimitiveType.NUMBER),
+      ),
+    );
+    percentile.values = [percentileValue];
+    if (
+      this.acending === undefined ||
+      this.continuous === undefined ||
+      (this.acending && this.continuous)
+    ) {
+      expression.parametersValues.push(
+        new VariableExpression(variableName, Multiplicity.ONE),
+        percentile,
+      );
+    } else {
+      const acending = new PrimitiveInstanceValue(
+        GenericTypeExplicitReference.create(
+          new GenericType(PrimitiveType.BOOLEAN),
+        ),
+      );
+      acending.values = [this.acending];
+      const continuous = new PrimitiveInstanceValue(
+        GenericTypeExplicitReference.create(
+          new GenericType(PrimitiveType.BOOLEAN),
+        ),
+      );
+      continuous.values = [this.continuous];
+      expression.parametersValues.push(
+        new VariableExpression(variableName, Multiplicity.ONE),
+        percentile,
+        acending,
+        continuous,
+      );
+    }
+    return expression;
+  }
+
+  buildAggregateColumnState(
+    expression: SimpleFunctionExpression,
+    lambdaParam: VariableExpression,
+    projectionColumnState: QueryBuilderProjectionColumnState,
+  ): QueryBuilderAggregateColumnState | undefined {
+    if (
+      matchFunctionName(
+        expression.functionName,
+        QUERY_BUILDER_SUPPORTED_FUNCTIONS.PERCENTILE,
+      )
+    ) {
+      const aggregateColumnState = new QueryBuilderAggregateColumnState(
+        projectionColumnState.tdsState.aggregationState,
+        projectionColumnState,
+        new QueryBuilderAggregateOperator_Percentile(),
+      );
+
+      const currentOperator = guaranteeType(
+        aggregateColumnState.operator,
+        QueryBuilderAggregateOperator_Percentile,
+      );
+
+      aggregateColumnState.setLambdaParameterName(lambdaParam.name);
+
+      assertTrue(
+        [2, 4].includes(expression.parametersValues.length),
+        `Can't process percentile() expression: percentile() expects 2 or 4 argument`,
+      );
+
+      // variable
+      const variableExpression = guaranteeType(
+        expression.parametersValues[0],
+        VariableExpression,
+        `Can't process percentile() expression: only support percentile() immediately following a variable expression`,
+      );
+      assertTrue(
+        aggregateColumnState.lambdaParameterName === variableExpression.name,
+        `Can't process percentile() expression: expects variable used in lambda body '${variableExpression.name}' to match lambda parameter '${aggregateColumnState.lambdaParameterName}'`,
+      );
+      const percentile = guaranteeType(
+        expression.parametersValues[1],
+        PrimitiveInstanceValue,
+        `Can't process percentile() expression: percentile() expects arugment #2 to be a primitive instance value`,
+      );
+      currentOperator.percentile = percentile.values[0] as number;
+
+      if (expression.parametersValues.length === 4) {
+        const acending = guaranteeType(
+          expression.parametersValues[2],
+          PrimitiveInstanceValue,
+          `Can't process percentile() expression: percentile() expects arugment #3 to be a primitive instance value`,
+        );
+        currentOperator.acending = acending.values[0] as boolean;
+        const continuous = guaranteeType(
+          expression.parametersValues[3],
+          PrimitiveInstanceValue,
+          `Can't process percentile() expression: percentile() expects arugment #4 to be a primitive instance value`,
+        );
+        currentOperator.continuous = continuous.values[0] as boolean;
+      }
+      // operator
+      assertTrue(
+        this.isCompatibleWithColumn(aggregateColumnState.projectionColumnState),
+        `Can't process percentile() expression: property is not compatible with operator`,
+      );
+      aggregateColumnState.setOperator(currentOperator);
+      return aggregateColumnState;
+    }
+
+    return undefined;
+  }
+
+  override get getOperator(): QueryBuilderAggregateOperator {
+    return new QueryBuilderAggregateOperator_Percentile();
+  }
+
+  override get allValidationIssues(): string[] {
+    const validationIssues: string[] = [];
+    if (this.percentile === undefined || this.percentile > 100) {
+      validationIssues.push('Invalid Aggregation Argument for Percentile');
+    }
+    return validationIssues;
+  }
+
+  get hashCode(): string {
+    return hashArray([
+      QUERY_BUILDER_STATE_HASH_STRUCTURE.AGGREGATE_OPERATOR_PERCENTILE,
+    ]);
+  }
+}

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

@@ -1000,12 +1000,10 @@ export class QueryBuilderPostFilterState
           node.condition.rightConditionValue instanceof
             PostFilterValueSpecConditionValueState &&
           node.condition.rightConditionValue.value instanceof InstanceValue &&
-          !isValidInstanceValue(node.condition.rightConditionValue.value) &&
-          node.condition.leftConditionValue instanceof
-            QueryBuilderSimpleProjectionColumnState
+          !isValidInstanceValue(node.condition.rightConditionValue.value)
         ) {
           validationIssues.push(
-            `Filter value for ${node.condition.leftConditionValue.propertyExpressionState.title} is missing or invalid`,
+            `Filter value for ${node.condition.leftConditionValue.columnName} is missing or invalid`,
           );
         }
         if (
@@ -1029,9 +1027,7 @@ export class QueryBuilderPostFilterState
         node.condition.rightConditionValue instanceof
           PostFilterValueSpecConditionValueState &&
         node.condition.rightConditionValue.value instanceof InstanceValue &&
-        !isValidInstanceValue(node.condition.rightConditionValue.value) &&
-        node.condition.leftConditionValue instanceof
-          QueryBuilderSimpleProjectionColumnState,
+        !isValidInstanceValue(node.condition.rightConditionValue.value),
     );
   }