@finos/legend-query-builder 3.0.8 → 3.1.0

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

@@ -28,6 +28,7 @@ import type { QueryBuilderAggregateOperator } from './QueryBuilderAggregateOpera
 import type { QueryBuilderProjectionColumnState } from '../projection/QueryBuilderProjectionColumnState.js';
 import { QUERY_BUILDER_STATE_HASH_STRUCTURE } from '../../../QueryBuilderStateHashUtils.js';
 import { QueryBuilderTDSColumnState } from '../QueryBuilderTDSColumnState.js';
+import type { QueryBuilderAggregateCalendarFunction } from './QueryBuilderAggregateCalendarFunction.js';
 
 export class QueryBuilderAggregateColumnState
   extends QueryBuilderTDSColumnState
@@ -37,6 +38,8 @@ export class QueryBuilderAggregateColumnState
   projectionColumnState: QueryBuilderProjectionColumnState;
   lambdaParameterName: string = DEFAULT_LAMBDA_VARIABLE_NAME;
   operator: QueryBuilderAggregateOperator;
+  calendarFunction?: QueryBuilderAggregateCalendarFunction | undefined;
+  hideCalendarColumnState = true;
 
   constructor(
     aggregationState: QueryBuilderAggregationState,
@@ -47,10 +50,14 @@ export class QueryBuilderAggregateColumnState
     makeObservable(this, {
       projectionColumnState: observable,
       lambdaParameterName: observable,
+      calendarFunction: observable,
+      hideCalendarColumnState: observable,
       operator: observable,
+      setHideCalendarColumnState: action,
       setColumnState: action,
       setLambdaParameterName: action,
       setOperator: action,
+      setCalendarFunction: action,
       hashCode: computed,
     });
 
@@ -58,6 +65,7 @@ export class QueryBuilderAggregateColumnState
     this.projectionColumnState = projectionColumnState;
     this.operator = operator;
   }
+
   setColumnState(val: QueryBuilderProjectionColumnState): void {
     this.projectionColumnState = val;
   }
@@ -66,6 +74,16 @@ export class QueryBuilderAggregateColumnState
     this.lambdaParameterName = val;
   }
 
+  setHideCalendarColumnState(val: boolean): void {
+    this.hideCalendarColumnState = val;
+  }
+
+  setCalendarFunction(
+    val: QueryBuilderAggregateCalendarFunction | undefined,
+  ): void {
+    this.calendarFunction = val;
+  }
+
   setOperator(val: QueryBuilderAggregateOperator): void {
     this.operator = val;
   }
@@ -78,6 +96,7 @@ export class QueryBuilderAggregateColumnState
     return hashArray([
       QUERY_BUILDER_STATE_HASH_STRUCTURE.AGGREGATE_COLUMN_STATE,
       this.operator,
+      this.calendarFunction ?? '',
     ]);
   }
 
@@ -89,22 +108,26 @@ export class QueryBuilderAggregateColumnState
 export class QueryBuilderAggregationState implements Hashable {
   readonly tdsState: QueryBuilderTDSState;
   readonly operators: QueryBuilderAggregateOperator[] = [];
+  readonly calendarFunctions: QueryBuilderAggregateCalendarFunction[];
   columns: QueryBuilderAggregateColumnState[] = [];
 
   constructor(
     tdsState: QueryBuilderTDSState,
     operators: QueryBuilderAggregateOperator[],
+    calendarFunctions: QueryBuilderAggregateCalendarFunction[],
   ) {
     makeObservable(this, {
       columns: observable,
       removeColumn: action,
       addColumn: action,
       changeColumnAggregateOperator: action,
+      disableCalendar: action,
       hashCode: computed,
     });
 
     this.tdsState = tdsState;
     this.operators = operators;
+    this.calendarFunctions = calendarFunctions;
   }
 
   removeColumn(val: QueryBuilderAggregateColumnState): void {
@@ -163,6 +186,14 @@ export class QueryBuilderAggregationState implements Hashable {
     }
   }
 
+  disableCalendar(): void {
+    this.tdsState.queryBuilderState.setIsCalendarEnabled(false);
+    this.columns.forEach((column) => {
+      column.setCalendarFunction(undefined);
+      column.setHideCalendarColumnState(true);
+    });
+  }
+
   get hashCode(): string {
     return hashArray([
       QUERY_BUILDER_STATE_HASH_STRUCTURE.AGGREGATION_STATE,

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

@@ -104,6 +104,28 @@ export const processTDSAggregateExpression = (
       `Can't process agg() lambda: only support agg() lambda body with 1 expression`,
     );
 
+    let calendarExpression: SimpleFunctionExpression | undefined;
+    if (queryBuilderState.isCalendarEnabled) {
+      const childExpression = expression.parametersValues[0];
+      assertType(
+        childExpression,
+        LambdaFunctionInstanceValue,
+        `Can't process agg() expression: agg() expects argument #0 to be a lambda function`,
+      );
+      const lambdaFunc1 = guaranteeNonNullable(
+        childExpression.values[0],
+        `Can't process agg() lambda: agg() lambda function is missing`,
+      );
+      assertTrue(
+        lambdaFunc1.expressionSequence.length === 1,
+        `Can't process agg() lambda: only support agg() lambda body with 1 expression`,
+      );
+      calendarExpression =
+        lambdaFunc1.expressionSequence[0] instanceof SimpleFunctionExpression
+          ? lambdaFunc1.expressionSequence[0]
+          : undefined;
+    }
+
     assertTrue(
       lambdaFunc.functionType.parameters.length === 1,
       `Can't process agg() lambda: only support agg() lambda with 1 parameter`,
@@ -128,6 +150,25 @@ export const processTDSAggregateExpression = (
       );
       if (aggregateColumnState) {
         aggregationState.addColumn(aggregateColumnState);
+        if (
+          queryBuilderState.isCalendarEnabled &&
+          calendarExpression !== undefined
+        ) {
+          for (const calendarFunction of aggregationState.calendarFunctions) {
+            // NOTE: this allow plugin author to either return `undefined` or throw error
+            // if there is a problem with building the lambda. Either case, the plugin is
+            // considered as not supporting the lambda.
+            returnUndefOnError(() =>
+              calendarFunction.updateAggregateColumnState(
+                guaranteeNonNullable(calendarExpression),
+                aggregateColumnState,
+              ),
+            );
+          }
+        }
+        if (!aggregateColumnState.calendarFunction) {
+          aggregateColumnState.setHideCalendarColumnState(true);
+        }
         return;
       }
     }

package/src/stores/fetch-structure/tds/aggregation/calendarFunctions/QueryBuilderAggregateCalendarFunctionValueSpecificationBuilder.ts

@@ -0,0 +1,175 @@
+/**
+ * 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 ValueSpecification,
+  SimpleFunctionExpression,
+  extractElementNameFromPath,
+  matchFunctionName,
+  AbstractPropertyExpression,
+  PrimitiveInstanceValue,
+  GenericType,
+  GenericTypeExplicitReference,
+  PrimitiveType,
+  PRIMITIVE_TYPE,
+  VariableExpression,
+} from '@finos/legend-graph';
+import {
+  guaranteeType,
+  assertTrue,
+  UnsupportedOperationError,
+} from '@finos/legend-shared';
+import type { QueryBuilderAggregateColumnState } from '../QueryBuilderAggregationState.js';
+import { type QueryBuilderAggregateCalendarFunction } from '../QueryBuilderAggregateCalendarFunction.js';
+import { QUERY_BUILDER_CALENDAR_TYPE } from '../../../../../graph-manager/QueryBuilderConst.js';
+
+export const buildCalendarFunctionExpression = (
+  calendarFunctionFullPath: string,
+  dateColumn: AbstractPropertyExpression | undefined,
+  calendarType: QUERY_BUILDER_CALENDAR_TYPE,
+  endDate: PrimitiveInstanceValue,
+  targetColumn: AbstractPropertyExpression,
+): ValueSpecification => {
+  const expression = new SimpleFunctionExpression(
+    extractElementNameFromPath(calendarFunctionFullPath),
+  );
+  if (dateColumn) {
+    expression.parametersValues.push(dateColumn);
+  } else {
+    throw new UnsupportedOperationError(
+      `Please specify date column for calendar Function for column ${targetColumn.func.value.name}`,
+    );
+  }
+  const calendarTypeParameter = new PrimitiveInstanceValue(
+    GenericTypeExplicitReference.create(new GenericType(PrimitiveType.STRING)),
+  );
+  calendarTypeParameter.values = [calendarType];
+  expression.parametersValues.push(calendarTypeParameter);
+  expression.parametersValues.push(endDate);
+  expression.parametersValues.push(targetColumn);
+  return expression;
+};
+
+export const updateAggregateColumnState = (
+  expression: SimpleFunctionExpression,
+  calendarFunctionFullPath: string,
+  calendarFunction: QueryBuilderAggregateCalendarFunction,
+  aggregateColumnState: QueryBuilderAggregateColumnState,
+): void => {
+  if (matchFunctionName(expression.functionName, calendarFunctionFullPath)) {
+    assertTrue(
+      expression.parametersValues.length === 4,
+      `Can't process ${extractElementNameFromPath(
+        calendarFunctionFullPath,
+      )}() expression: ${extractElementNameFromPath(
+        calendarFunctionFullPath,
+      )}() expects four arguments`,
+    );
+
+    const dateColumn = guaranteeType(
+      expression.parametersValues[0],
+      AbstractPropertyExpression,
+      `Can't process ${extractElementNameFromPath(
+        calendarFunctionFullPath,
+      )}() expression: only support ${extractElementNameFromPath(
+        calendarFunctionFullPath,
+      )}() with first parameter as property expression`,
+    );
+    assertTrue(
+      dateColumn.func.value.genericType.value.rawType.name ===
+        PRIMITIVE_TYPE.STRICTDATE ||
+        dateColumn.func.value.genericType.value.rawType.name ===
+          PRIMITIVE_TYPE.DATE,
+
+      `Can't process ${extractElementNameFromPath(
+        calendarFunctionFullPath,
+      )}() expression: only support ${extractElementNameFromPath(
+        calendarFunctionFullPath,
+      )}() with first parameter as property expression of type StrictDate`,
+    );
+    const lambdaParameterName = guaranteeType(
+      dateColumn.parametersValues[0],
+      VariableExpression,
+    ).name;
+    calendarFunction.setLambdaParameterName(lambdaParameterName);
+
+    const calendarTypeParameter = guaranteeType(
+      expression.parametersValues[1],
+      PrimitiveInstanceValue,
+      `Can't process ${extractElementNameFromPath(
+        calendarFunctionFullPath,
+      )}() expression: only support ${extractElementNameFromPath(
+        calendarFunctionFullPath,
+      )}() with second parameter as PrimitiveInstancevalue`,
+    );
+    assertTrue(
+      Object.values(QUERY_BUILDER_CALENDAR_TYPE).find(
+        (val) => val === calendarTypeParameter.values[0],
+      ) !== undefined,
+      `Can't process ${extractElementNameFromPath(
+        calendarFunctionFullPath,
+      )}() expression: only support ${extractElementNameFromPath(
+        calendarFunctionFullPath,
+      )}() calendar types NY and LDN`,
+    );
+
+    const endDate = guaranteeType(
+      expression.parametersValues[2],
+      PrimitiveInstanceValue,
+      `Can't process ${extractElementNameFromPath(
+        calendarFunctionFullPath,
+      )}() expression: only support ${extractElementNameFromPath(
+        calendarFunctionFullPath,
+      )}() with third parameter as PrimitiveInstancevalue`,
+    );
+    assertTrue(
+      endDate.genericType.value.rawType.name === PRIMITIVE_TYPE.STRICTDATE ||
+        dateColumn.func.value.genericType.value.rawType.name ===
+          PRIMITIVE_TYPE.DATE,
+
+      `Can't process ${extractElementNameFromPath(
+        calendarFunctionFullPath,
+      )}() expression: only support ${extractElementNameFromPath(
+        calendarFunctionFullPath,
+      )}() with third parameter of type StrictDate`,
+    );
+
+    guaranteeType(
+      expression.parametersValues[3],
+      AbstractPropertyExpression,
+      `Can't process ${extractElementNameFromPath(
+        calendarFunctionFullPath,
+      )}() expression: only support ${extractElementNameFromPath(
+        calendarFunctionFullPath,
+      )}() fourth parameter as property expression`,
+    );
+
+    calendarFunction.calendarType = calendarTypeParameter
+      .values[0] as QUERY_BUILDER_CALENDAR_TYPE;
+    calendarFunction.endDate = endDate;
+    calendarFunction.dateColumn = dateColumn;
+    assertTrue(
+      calendarFunction.isCompatibleWithColumn(
+        aggregateColumnState.projectionColumnState,
+      ),
+      `Can't process ${extractElementNameFromPath(
+        calendarFunctionFullPath,
+      )}() expression: property is not compatible with calendar function`,
+    );
+    aggregateColumnState.setHideCalendarColumnState(false);
+    aggregateColumnState.setCalendarFunction(calendarFunction);
+  }
+};

package/src/stores/fetch-structure/tds/aggregation/calendarFunctions/QueryBuilderAggregateCalendarFunction_Annualized.ts

@@ -0,0 +1,98 @@
+/**
+ * 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 {
+  PRIMITIVE_TYPE,
+  type ValueSpecification,
+  type SimpleFunctionExpression,
+  type AbstractPropertyExpression,
+} from '@finos/legend-graph';
+import type { QueryBuilderAggregateColumnState } from '../QueryBuilderAggregationState.js';
+import {
+  type QueryBuilderProjectionColumnState,
+  QueryBuilderSimpleProjectionColumnState,
+} from '../../projection/QueryBuilderProjectionColumnState.js';
+import { QueryBuilderAggregateCalendarFunction } from '../QueryBuilderAggregateCalendarFunction.js';
+import {
+  updateAggregateColumnState,
+  buildCalendarFunctionExpression,
+} from './QueryBuilderAggregateCalendarFunctionValueSpecificationBuilder.js';
+import { QUERY_BUILDER_SUPPORTED_CALENDAR_AGGREGATION_FUNCTIONS } from '../../../../../graph/QueryBuilderMetaModelConst.js';
+import { hashArray, type Hashable } from '@finos/legend-shared';
+import { QUERY_BUILDER_STATE_HASH_STRUCTURE } from '../../../../QueryBuilderStateHashUtils.js';
+
+export class QueryBuilderAggregateCalendarFunction_Annualized
+  extends QueryBuilderAggregateCalendarFunction
+  implements Hashable
+{
+  getLabel(): string {
+    return 'Annualized';
+  }
+
+  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;
+  }
+
+  buildCalendarFunctionExpression(
+    p: AbstractPropertyExpression,
+  ): ValueSpecification {
+    return buildCalendarFunctionExpression(
+      QUERY_BUILDER_SUPPORTED_CALENDAR_AGGREGATION_FUNCTIONS.CALENDAR_ANNUALIZED,
+      this.dateColumn,
+      this.calendarType,
+      this.endDate,
+      p,
+    );
+  }
+
+  updateAggregateColumnState(
+    expression: SimpleFunctionExpression,
+    aggregationColumnState: QueryBuilderAggregateColumnState,
+  ): void {
+    updateAggregateColumnState(
+      expression,
+      QUERY_BUILDER_SUPPORTED_CALENDAR_AGGREGATION_FUNCTIONS.CALENDAR_ANNUALIZED,
+      this,
+      aggregationColumnState,
+    );
+  }
+
+  get hashCode(): string {
+    return hashArray([
+      QUERY_BUILDER_STATE_HASH_STRUCTURE.AGGREGATE_CALENDAR_FUNCTION_ANNUALIZED,
+      this.dateColumn ?? '',
+      this.calendarType,
+      this.endDate,
+    ]);
+  }
+}

package/src/stores/fetch-structure/tds/aggregation/calendarFunctions/QueryBuilderAggregateCalendarFunction_Cme.ts

@@ -0,0 +1,98 @@
+/**
+ * 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 {
+  PRIMITIVE_TYPE,
+  type ValueSpecification,
+  type SimpleFunctionExpression,
+  type AbstractPropertyExpression,
+} from '@finos/legend-graph';
+import type { QueryBuilderAggregateColumnState } from '../QueryBuilderAggregationState.js';
+import {
+  type QueryBuilderProjectionColumnState,
+  QueryBuilderSimpleProjectionColumnState,
+} from '../../projection/QueryBuilderProjectionColumnState.js';
+import { QUERY_BUILDER_SUPPORTED_CALENDAR_AGGREGATION_FUNCTIONS } from '../../../../../graph/QueryBuilderMetaModelConst.js';
+import { hashArray, type Hashable } from '@finos/legend-shared';
+import { QUERY_BUILDER_STATE_HASH_STRUCTURE } from '../../../../QueryBuilderStateHashUtils.js';
+import { QueryBuilderAggregateCalendarFunction } from '../QueryBuilderAggregateCalendarFunction.js';
+import {
+  updateAggregateColumnState,
+  buildCalendarFunctionExpression,
+} from './QueryBuilderAggregateCalendarFunctionValueSpecificationBuilder.js';
+
+export class QueryBuilderAggregateCalendarFunction_Cme
+  extends QueryBuilderAggregateCalendarFunction
+  implements Hashable
+{
+  getLabel(): string {
+    return `Current Month Estimate`;
+  }
+
+  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;
+  }
+
+  buildCalendarFunctionExpression(
+    p: AbstractPropertyExpression,
+  ): ValueSpecification {
+    return buildCalendarFunctionExpression(
+      QUERY_BUILDER_SUPPORTED_CALENDAR_AGGREGATION_FUNCTIONS.CALENDAR_CME,
+      this.dateColumn,
+      this.calendarType,
+      this.endDate,
+      p,
+    );
+  }
+
+  updateAggregateColumnState(
+    expression: SimpleFunctionExpression,
+    aggregationColumnState: QueryBuilderAggregateColumnState,
+  ): void {
+    updateAggregateColumnState(
+      expression,
+      QUERY_BUILDER_SUPPORTED_CALENDAR_AGGREGATION_FUNCTIONS.CALENDAR_CME,
+      this,
+      aggregationColumnState,
+    );
+  }
+
+  get hashCode(): string {
+    return hashArray([
+      QUERY_BUILDER_STATE_HASH_STRUCTURE.AGGREGATE_CALENDAR_FUNCTION_CME,
+      this.dateColumn ?? '',
+      this.calendarType,
+      this.endDate,
+    ]);
+  }
+}

package/src/stores/fetch-structure/tds/aggregation/calendarFunctions/QueryBuilderAggregateCalendarFunction_Cw.ts

@@ -0,0 +1,98 @@
+/**
+ * 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 {
+  PRIMITIVE_TYPE,
+  type ValueSpecification,
+  type SimpleFunctionExpression,
+  type AbstractPropertyExpression,
+} from '@finos/legend-graph';
+import type { QueryBuilderAggregateColumnState } from '../QueryBuilderAggregationState.js';
+import {
+  type QueryBuilderProjectionColumnState,
+  QueryBuilderSimpleProjectionColumnState,
+} from '../../projection/QueryBuilderProjectionColumnState.js';
+import { QUERY_BUILDER_SUPPORTED_CALENDAR_AGGREGATION_FUNCTIONS } from '../../../../../graph/QueryBuilderMetaModelConst.js';
+import { hashArray, type Hashable } from '@finos/legend-shared';
+import { QUERY_BUILDER_STATE_HASH_STRUCTURE } from '../../../../QueryBuilderStateHashUtils.js';
+import { QueryBuilderAggregateCalendarFunction } from '../QueryBuilderAggregateCalendarFunction.js';
+import {
+  updateAggregateColumnState,
+  buildCalendarFunctionExpression,
+} from './QueryBuilderAggregateCalendarFunctionValueSpecificationBuilder.js';
+
+export class QueryBuilderAggregateCalendarFunction_Cw
+  extends QueryBuilderAggregateCalendarFunction
+  implements Hashable
+{
+  getLabel(): string {
+    return `Current Week`;
+  }
+
+  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;
+  }
+
+  buildCalendarFunctionExpression(
+    p: AbstractPropertyExpression,
+  ): ValueSpecification {
+    return buildCalendarFunctionExpression(
+      QUERY_BUILDER_SUPPORTED_CALENDAR_AGGREGATION_FUNCTIONS.CALENDAR_CW,
+      this.dateColumn,
+      this.calendarType,
+      this.endDate,
+      p,
+    );
+  }
+
+  updateAggregateColumnState(
+    expression: SimpleFunctionExpression,
+    aggregationColumnState: QueryBuilderAggregateColumnState,
+  ): void {
+    updateAggregateColumnState(
+      expression,
+      QUERY_BUILDER_SUPPORTED_CALENDAR_AGGREGATION_FUNCTIONS.CALENDAR_CW,
+      this,
+      aggregationColumnState,
+    );
+  }
+
+  get hashCode(): string {
+    return hashArray([
+      QUERY_BUILDER_STATE_HASH_STRUCTURE.AGGREGATE_CALENDAR_FUNCTION_CW,
+      this.dateColumn ?? '',
+      this.calendarType,
+      this.endDate,
+    ]);
+  }
+}