@finos/legend-application-repl 0.0.54 → 0.0.55

package/src/stores/dataCube/core/DataCubeQueryBuilder.ts

@@ -33,6 +33,7 @@ import {
 } from './DataCubeQuerySnapshot.js';
 import {
   guaranteeNonNullable,
+  isNonNullable,
   UnsupportedOperationError,
 } from '@finos/legend-shared';
 import {
@@ -53,15 +54,16 @@ import {
   _filter,
   _function,
   _groupByAggCols,
-  _groupByExtend,
   _lambda,
   _primitiveValue,
   _var,
 } from './DataCubeQueryBuilderUtils.js';
+import type { DataCubeQueryAggregateOperation } from './aggregation/DataCubeQueryAggregateOperation.js';
 
 export function buildExecutableQuery(
   snapshot: DataCubeQuerySnapshot,
   filterOperations: DataCubeQueryFilterOperation[],
+  aggregateOperations: DataCubeQueryAggregateOperation[],
   options?: {
     postProcessor?: (
       snapshot: DataCubeQuerySnapshot,
@@ -69,6 +71,7 @@ export function buildExecutableQuery(
       funcMap: DataCubeQueryFunctionMap,
       configuration: DataCubeConfiguration,
       filterOperations: DataCubeQueryFilterOperation[],
+      aggregateOperations: DataCubeQueryAggregateOperation[],
     ) => void;
     pagination?:
       | {
@@ -144,22 +147,20 @@ export function buildExecutableQuery(
       'groupBy',
       _function(_name(DataCubeFunction.GROUP_BY), [
         _cols(groupBy.columns.map((col) => _colSpec(col.name))),
-        _cols(_groupByAggCols(groupBy.aggColumns)),
+        _cols(
+          _groupByAggCols(
+            groupBy.columns,
+            snapshot,
+            configuration,
+            aggregateOperations,
+          ),
+        ),
       ]),
     );
-
-    // extend columns to maintain the same set of columns prior to groupBy()
-    const groupByExtend = _groupByExtend(snapshot.stageCols('aggregation'), [
-      ...groupBy.columns,
-      ...groupBy.aggColumns,
-    ]);
-    if (groupByExtend) {
-      _process('groupByExtend', groupByExtend);
-    }
   }
 
   // --------------------------------- PIVOT ---------------------------------
-  // TODO: @akphi - implement this and CAST
+  /** TODO: @datacube pivot - implement this and CAST */
 
   // --------------------------------- GROUP-LEVEL EXTEND ---------------------------------
 
@@ -229,7 +230,13 @@ export function buildExecutableQuery(
   // --------------------------------- FROM ---------------------------------
 
   sequence.push(
-    _function(_name(DataCubeFunction.FROM), [_elementPtr(data.runtime)]),
+    _function(
+      _name(DataCubeFunction.FROM),
+      [
+        data.mapping ? _elementPtr(data.mapping) : undefined,
+        _elementPtr(data.runtime),
+      ].filter(isNonNullable),
+    ),
   );
 
   // --------------------------------- FINALIZE ---------------------------------
@@ -240,6 +247,7 @@ export function buildExecutableQuery(
     funcMap,
     configuration,
     filterOperations,
+    aggregateOperations,
   );
 
   if (!sequence.length) {

package/src/stores/dataCube/core/DataCubeQueryBuilderUtils.ts

@@ -44,15 +44,15 @@ import {
   type V1_PrimitiveValueSpecification,
   V1_Variable,
   V1_deserializeValueSpecification,
-  extractElementNameFromPath as _functionName,
+  extractElementNameFromPath,
   type V1_ValueSpecification,
+  extractPackagePathFromPath,
 } from '@finos/legend-graph';
 import {
   type DataCubeQuerySnapshotFilterCondition,
   type DataCubeQuerySnapshotFilter,
-  _findCol,
   type DataCubeQuerySnapshotColumn,
-  type DataCubeQuerySnapshotAggregateColumn,
+  type DataCubeQuerySnapshot,
 } from './DataCubeQuerySnapshot.js';
 import {
   guaranteeNonNullable,
@@ -68,11 +68,12 @@ import {
   DEFAULT_LAMBDA_VARIABLE_NAME,
   INTERNAL__FILLER_COUNT_AGG_COLUMN_NAME,
   DataCubeQueryFilterGroupOperator,
-  DataCubeAggregateOperator,
   type DataCubeOperationValue,
   DataCubeOperationAdvancedValueType,
 } from './DataCubeQueryEngine.js';
 import type { DataCubeQueryFilterOperation } from './filter/DataCubeQueryFilterOperation.js';
+import type { DataCubeQueryAggregateOperation } from './aggregation/DataCubeQueryAggregateOperation.js';
+import type { DataCubeConfiguration } from './DataCubeConfiguration.js';
 
 // --------------------------------- UTILITIES ---------------------------------
 
@@ -103,7 +104,52 @@ export function _lambda(
   return lambda;
 }
 
-export { _functionName };
+// NOTE: the list of auto-import are kept in `m3.pure` file in `finos/legend-pure`,
+// this includes a more extensive list of packges which contain native functions, classes, etc.
+// See https://github.com/finos/legend-pure/blob/master/legend-pure-core/legend-pure-m3-core/src/main/resources/platform/pure/grammar/m3.pure
+const PURE_AUTO_IMPORT_PACKAGE_PATHS = [
+  'meta::pure::metamodel',
+  'meta::pure::metamodel::type',
+  'meta::pure::metamodel::type::generics',
+  'meta::pure::metamodel::relationship',
+  'meta::pure::metamodel::valuespecification',
+  'meta::pure::metamodel::multiplicity',
+  'meta::pure::metamodel::function',
+  'meta::pure::metamodel::function::property',
+  'meta::pure::metamodel::extension',
+  'meta::pure::metamodel::import',
+  'meta::pure::functions::date',
+  'meta::pure::functions::string',
+  'meta::pure::functions::collection',
+  'meta::pure::functions::meta',
+  'meta::pure::functions::constraints',
+  'meta::pure::functions::lang',
+  'meta::pure::functions::boolean',
+  'meta::pure::functions::tools',
+  'meta::pure::functions::relation',
+  'meta::pure::functions::io',
+  'meta::pure::functions::math',
+  'meta::pure::functions::asserts',
+  'meta::pure::functions::test',
+  'meta::pure::functions::multiplicity',
+  'meta::pure::router',
+  'meta::pure::service',
+  'meta::pure::tds',
+  'meta::pure::tools',
+  'meta::pure::profiles',
+];
+
+export function _functionName(funcNameOrPath: string) {
+  const funcPakagePath = extractPackagePathFromPath(funcNameOrPath);
+  if (
+    funcPakagePath &&
+    PURE_AUTO_IMPORT_PACKAGE_PATHS.includes(funcPakagePath)
+  ) {
+    return extractElementNameFromPath(funcNameOrPath);
+  }
+  return funcNameOrPath;
+}
+
 export function _function(
   functionName: string,
   parameters: V1_ValueSpecification[],
@@ -209,48 +255,6 @@ export function _value(
   }
 }
 
-function _aggFunctionName(operation: string) {
-  switch (operation) {
-    case DataCubeAggregateOperator.SUM:
-      return DataCubeFunction.SUM;
-    case DataCubeAggregateOperator.AVERAGE:
-      return DataCubeFunction.AVERAGE;
-    case DataCubeAggregateOperator.COUNT:
-      return DataCubeFunction.COUNT;
-    case DataCubeAggregateOperator.MIN:
-      return DataCubeFunction.MIN;
-    case DataCubeAggregateOperator.MAX:
-      return DataCubeFunction.MAX;
-    case DataCubeAggregateOperator.FIRST:
-      return DataCubeFunction.FIRST;
-    case DataCubeAggregateOperator.LAST:
-      return DataCubeFunction.LAST;
-    case DataCubeAggregateOperator.VAR_POP:
-      return DataCubeFunction.VAR_POP;
-    case DataCubeAggregateOperator.VAR_SAMP:
-      return DataCubeFunction.VAR_SAMP;
-    case DataCubeAggregateOperator.STDDEV_POP:
-      return DataCubeFunction.STDDEV_POP;
-    case DataCubeAggregateOperator.STDDEV_SAMP:
-      return DataCubeFunction.STDDEV_SAMP;
-    default:
-      throw new UnsupportedOperationError(
-        `Unsupported aggregate operation '${operation}'`,
-      );
-  }
-}
-
-function _agg(
-  agg: DataCubeQuerySnapshotAggregateColumn,
-  variable?: V1_Variable | undefined,
-) {
-  const parameters = agg.parameters.map((param) => _value(param));
-  return _function(_aggFunctionName(agg.operation), [
-    variable ?? _var(),
-    ...parameters,
-  ]);
-}
-
 export function _not(fn: V1_AppliedFunction) {
   return _function(DataCubeFunction.NOT, [fn]);
 }
@@ -274,18 +278,45 @@ export function _cols(colSpecs: V1_ColSpec[]) {
   return _classInstance(V1_ClassInstanceType.COL_SPEC_ARRAY, colSpecArray);
 }
 
+export function _aggCol_basic(
+  column: DataCubeQuerySnapshotColumn,
+  func: string,
+) {
+  const variable = _var();
+  return _colSpec(
+    column.name,
+    _lambda([variable], [_property(column.name, variable)]),
+    _lambda([variable], [_function(_functionName(func), [variable])]),
+  );
+}
+
 export function _groupByAggCols(
-  columns: DataCubeQuerySnapshotAggregateColumn[],
+  groupByColumns: DataCubeQuerySnapshotColumn[],
+  snapshot: DataCubeQuerySnapshot,
+  configuration: DataCubeConfiguration,
+  aggregateOperations: DataCubeQueryAggregateOperation[],
 ) {
   const variable = _var();
-  return columns.length
-    ? columns.map((agg) =>
-        _colSpec(
-          agg.name,
-          _lambda([variable], [_property(agg.name, variable)]),
-          _lambda([variable], [_agg(agg)]),
-        ),
-      )
+  const aggColumns = configuration.columns.filter(
+    (column) =>
+      !groupByColumns.find((col) => col.name === column.name) &&
+      !snapshot.data.groupExtendedColumns.find(
+        (col) => col.name === column.name,
+      ),
+  );
+  return aggColumns.length
+    ? aggColumns.map((agg) => {
+        const operation = aggregateOperations.find(
+          (op) => op.operator === agg.aggregateOperator,
+        );
+        const aggCol = operation?.buildAggregateColumn(agg);
+        if (!aggCol) {
+          throw new UnsupportedOperationError(
+            `Unsupported aggregate operation '${agg.aggregateOperator}'`,
+          );
+        }
+        return aggCol;
+      })
     : // if no aggregates are specified, add a dummy count() aggregate to satisfy compiler
       [
         _colSpec(
@@ -331,24 +362,3 @@ export function _filter(
     return filterCondition.not ? _not(condition) : condition;
   }
 }
-
-export function _groupByExtend(
-  columns: DataCubeQuerySnapshotColumn[],
-  columnsUsedInGroupBy: DataCubeQuerySnapshotColumn[],
-) {
-  const missingCols = columns.filter(
-    (col) => !_findCol(columnsUsedInGroupBy, col.name),
-  );
-  return missingCols.length
-    ? _function(_functionName(DataCubeFunction.EXTEND), [
-        _cols(
-          missingCols.map((col) =>
-            _colSpec(
-              col.name,
-              _lambda([_var()], [_primitiveValue(PRIMITIVE_TYPE.STRING, '')]),
-            ),
-          ),
-        ),
-      ])
-    : undefined;
-}

package/src/stores/dataCube/core/DataCubeQueryEngine.ts

@@ -64,11 +64,11 @@ export enum DataCubeFunction {
   MAX = 'meta::pure::functions::collection::max',
   MIN = 'meta::pure::functions::collection::min',
   SUM = 'meta::pure::functions::math::sum',
-  STDDEV_POP = 'meta::pure::functions::math::stdDevPopulation',
-  STDDEV_SAMP = 'meta::pure::functions::math::stdDevSample',
-  VAR_POP = 'meta::pure::functions::math::variancePopulation',
-  VAR_SAMP = 'meta::pure::functions::math::varianceSample',
-  // UNIQUE_VALUE_ONLY = 'meta::pure::functions::collection::uniqueValueOnly',
+  STANDARD_DEVIATION_POPULATION = 'meta::pure::functions::math::stdDevPopulation',
+  STANDARD_DEVIATION_SAMPLE = 'meta::pure::functions::math::stdDevSample',
+  UNIQUE_VALUE_ONLY = 'meta::pure::functions::collection::uniqueValueOnly',
+  VARIANCE_POPULATION = 'meta::pure::functions::math::variancePopulation',
+  VARIANCE_SAMPLE = 'meta::pure::functions::math::varianceSample',
   // PERCENTILE = 'meta::pure::functions::math::percentile',
 }
 
@@ -86,8 +86,7 @@ export type DataCubeQueryFunctionMap = {
   leafExtend?: V1_AppliedFunction | undefined;
   filter?: V1_AppliedFunction | undefined;
   groupBy?: V1_AppliedFunction | undefined;
-  groupByExtend?: V1_AppliedFunction | undefined; // used to populate empty columns erased by groupBy()
-  pivotExtend?: V1_AppliedFunction | undefined; // used to populate columns erased by pivot()
+  pivotExtend?: V1_AppliedFunction | undefined; // used to populate columns to be erased by pivot()
   pivot?: V1_AppliedFunction | undefined;
   pivotCast?: V1_AppliedFunction | undefined; // used to set the relation type post pivot() to make compilation works properly
   groupExtend?: V1_AppliedFunction | undefined;
@@ -172,14 +171,14 @@ export enum DataCubeAggregateOperator {
   COUNT = 'count',
   MIN = 'min',
   MAX = 'max',
-  // UNIQUE = 'uniq',
+  UNIQUE = 'uniq',
   FIRST = 'first',
   LAST = 'last',
   // MEDIAN = 'median',
-  VAR_POP = 'var_samp',
-  VAR_SAMP = 'var_pop',
-  STDDEV_POP = 'stddev_pop',
-  STDDEV_SAMP = 'stddev_samp',
+  VARIANCE_POPULATION = 'var',
+  VARIANCE_SAMPLE = 'var_sample',
+  STANDARD_DEVIATION_POPULATION = 'std',
+  STANDARD_DEVIATION_SAMPLE = 'std_sample',
   // STANDARD_ERROR = 'stderr',
   // NULL = 'null',
   // ssq
@@ -190,7 +189,7 @@ export enum DataCubeAggregateOperator {
   // maxmagnitude
   // commonprefix
   // commonprefixunstrict
-  // strjoin
+  JOIN_STRINGS = 'strjoin',
   // strjoinuniq
   // splitjoin
   // daterange

package/src/stores/dataCube/core/DataCubeQuerySnapshot.ts

@@ -18,6 +18,7 @@ import type { V1_Lambda, V1_ValueSpecification } from '@finos/legend-graph';
 import type { DataCubeConfiguration } from './DataCubeConfiguration.js';
 import {
   IllegalStateError,
+  UnsupportedOperationError,
   guaranteeNonNullable,
   hashObject,
   pruneObject,
@@ -62,26 +63,19 @@ export type DataCubeQuerySnapshotSortColumn = DataCubeQuerySnapshotColumn & {
   operation: string;
 };
 
-export type DataCubeQuerySnapshotAggregateColumn =
-  DataCubeQuerySnapshotColumn & {
-    operation: string;
-    parameters: DataCubeOperationValue[];
-  };
-
 export type DataCubeQuerySnapshotGroupBy = {
   columns: DataCubeQuerySnapshotColumn[];
-  aggColumns: DataCubeQuerySnapshotAggregateColumn[];
 };
 
 export type DataCubeQuerySnapshotPivot = {
   columns: DataCubeQuerySnapshotColumn[];
-  aggColumns: DataCubeQuerySnapshotAggregateColumn[];
   castColumns: DataCubeQuerySnapshotColumn[];
 };
 
 export type DataCubeQuerySnapshotData = {
   name: string;
   runtime: string;
+  mapping: string | undefined;
   sourceQuery: PlainObject<V1_ValueSpecification>;
   configuration: PlainObject<DataCubeConfiguration>;
   sourceColumns: DataCubeQuerySnapshotColumn[];
@@ -114,12 +108,14 @@ export class DataCubeQuerySnapshot {
   private constructor(
     name: string,
     runtime: string,
+    mapping: string | undefined,
     sourceQuery: PlainObject<V1_ValueSpecification>,
     configuration: PlainObject<DataCubeConfiguration>,
   ) {
     this.data = {
       name,
       runtime,
+      mapping,
       sourceQuery,
       configuration,
       sourceColumns: [],
@@ -137,14 +133,21 @@ export class DataCubeQuerySnapshot {
   static create(
     name: string,
     runtime: string,
+    mapping: string | undefined,
     sourceQuery: PlainObject<V1_ValueSpecification>,
     configuration: PlainObject<DataCubeConfiguration>,
   ) {
-    return new DataCubeQuerySnapshot(name, runtime, sourceQuery, configuration);
+    return new DataCubeQuerySnapshot(
+      name,
+      runtime,
+      mapping,
+      sourceQuery,
+      configuration,
+    );
   }
 
   clone() {
-    const clone = new DataCubeQuerySnapshot('', '', {}, {});
+    const clone = new DataCubeQuerySnapshot('', '', '', {}, {});
     (clone.data as Writable<DataCubeQuerySnapshotData>) = JSON.parse(
       JSON.stringify(this.data),
     ) as DataCubeQuerySnapshotData;
@@ -164,8 +167,9 @@ export class DataCubeQuerySnapshot {
       case 'aggregation':
         return [...this.data.selectColumns];
       case 'group-extend':
-        // TODO: @akphi - add pivot columns
-        return [...this.data.selectColumns];
+        throw new UnsupportedOperationError(
+          `Can't get columns for group-level extend stage: dynamic pivot columns cannot be accounted for`,
+        );
       case 'sort':
         return [...this.data.selectColumns, ...this.data.groupExtendedColumns];
       default:

package/src/stores/dataCube/core/DataCubeQuerySnapshotBuilder.ts

@@ -46,7 +46,6 @@ import {
 import { DataCubeConfiguration } from './DataCubeConfiguration.js';
 import { buildDefaultConfiguration } from './DataCubeConfigurationBuilder.js';
 import {
-  _aggCol,
   _colSpecArrayParam,
   _colSpecParam,
   _funcMatch,
@@ -270,6 +269,7 @@ export function validateAndBuildQuerySnapshot(
   const snapshot = DataCubeQuerySnapshot.create(
     baseQuery.name,
     baseQuery.source.runtime,
+    baseQuery.source.mapping,
     V1_serializeValueSpecification(sourceQuery, []),
     {},
   );
@@ -295,12 +295,13 @@ export function validateAndBuildQuerySnapshot(
   data.sourceColumns.map((col) => colsMap.set(col.name, col));
 
   // --------------------------------- LEAF-LEVEL EXTEND ---------------------------------
-  // TODO: @akphi - implement this
+  /** TODO: @datacube roundtrip */
 
   // --------------------------------- FILTER ---------------------------------
 
   if (funcMap.filter) {
-    data.filter = undefined; // TODO: @akphi - implement this
+    /** TODO: @datacube roundtrip */
+    data.filter = undefined;
     // data.selectColumns = _colSpecArrayParam(funcMap.select, 0).colSpecs.map(
     //   (colSpec) => ({
     //     _col(colSpec),
@@ -323,21 +324,19 @@ export function validateAndBuildQuerySnapshot(
       columns: _colSpecArrayParam(funcMap.groupBy, 0).colSpecs.map((colSpec) =>
         _col(colSpec),
       ),
-      aggColumns: _colSpecArrayParam(funcMap.groupBy, 1).colSpecs.map(
-        (colSpec) => _aggCol(colSpec, _col(colSpec)),
-      ),
-      // TODO: verify agg columns agree with pivot agg columns
+      // TODO: verify group-by agg columns, pivot agg columns and configuration agree
     };
   }
 
   // --------------------------------- PIVOT ---------------------------------
-  // TODO: @akphi - implement this
+  /** TODO: @datacube roundtrip */
+  // TODO: verify group-by agg columns, pivot agg columns and configuration agree
 
   // --------------------------------- CAST ---------------------------------
-  // TODO: @akphi - implement this
+  /** TODO: @datacube roundtrip */
 
   // --------------------------------- GROUP-LEVEL EXTEND ---------------------------------
-  // TODO: @akphi - implement this
+  /** TODO: @datacube roundtrip */
 
   // --------------------------------- SORT ---------------------------------
 
@@ -368,25 +367,37 @@ export function validateAndBuildQuerySnapshot(
   }
 
   // --------------------------------- CONFIGURATION ---------------------------------
-  // The data query takes precedence over the configuration, we do this for 2 reasons
-  // 1. The purpose of the configuration is to provide the layout and styling
-  //    customization on top of the data query result grid. If conflicts happen between
-  //    the configuration and the query, we will reconciliate by modifying the configuration
-  // 2. The configuration when missing, can be generated from default presets. This helps
-  //    helps with use cases where the query might comes from a different source, such as
-  //    Studio or Query, or another part of Engine.
-
+  // NOTE: we aim to keep the data query a Pure query instead of a specification object
+  // so this configuration holds mostly layout and styling customization.
+  // But there are overlaps, i.e. certain data query configuration are stored in the
+  // configuration, e.g. column aggregation type, this is because a column
+  // aggregation's preference can be populated even when there's no aggregation specified
+  // in the data query.
+  //
+  // Arguably, the query should be the single source for these information, but when
+  // the configuration for a particular data query function coming from multiple sources
+  // conflict, we need to do some reconciliation (or throw error). Some examples include:
+  // - missing/extra columns present in the configuration
+  // - column kind and type conflict with aggregation
+  // - column kind and type conflict with the column configuration
+  //
+  // In certain cases, configuration needs to be generated from default presets. This
+  // helps with use cases where the query might comes from a different source, such as
+  // Studio or Query, or another part of Engine.
   const configuration = baseQuery.configuration
     ? DataCubeConfiguration.serialization.fromJson(baseQuery.configuration)
     : buildDefaultConfiguration(baseQuery.source.columns);
   data.configuration =
     DataCubeConfiguration.serialization.toJson(configuration);
-  // TODO: @akphi - implement the logic to reconcile the configuration with the query
-  // - columns (missing/extra columns - remove or generate default column configuration)
-  // - column kind
-  // - column type
-  // - base off the type, check the settings
-  // - aggregation
+  /**
+   * TODO: @datacube roundtrip - implement the logic to reconcile the configuration with the query
+   * - columns (missing/extra columns - remove or generate default column configuration)
+   * - column kind
+   * - column type
+   * - base off the type, check the settings
+   * - aggregation
+   * - verify group-by agg columns, pivot agg columns and configuration agree
+   */
 
   return snapshot.finalize();
 }

package/src/stores/dataCube/core/DataCubeQuerySnapshotBuilderUtils.ts

@@ -15,7 +15,6 @@
  */
 
 import {
-  PRIMITIVE_TYPE,
   V1_AppliedFunction,
   V1_ClassInstance,
   V1_ColSpec,
@@ -25,10 +24,7 @@ import {
   matchFunctionName,
   type V1_ValueSpecification,
 } from '@finos/legend-graph';
-import {
-  type DataCubeQuerySnapshotAggregateColumn,
-  type DataCubeQuerySnapshotColumn,
-} from './DataCubeQuerySnapshot.js';
+import { type DataCubeQuerySnapshotColumn } from './DataCubeQuerySnapshot.js';
 import {
   assertTrue,
   assertType,
@@ -108,27 +104,6 @@ function _aggFuncMatch(
   return _funcMatch(value.body[0], functionNames);
 }
 
-export function _defaultAggCol(
-  name: string,
-  type: string,
-): DataCubeQuerySnapshotAggregateColumn | undefined {
-  switch (type) {
-    case PRIMITIVE_TYPE.NUMBER:
-    case PRIMITIVE_TYPE.INTEGER:
-    case PRIMITIVE_TYPE.DECIMAL:
-    case PRIMITIVE_TYPE.FLOAT: {
-      return {
-        name,
-        type,
-        operation: DataCubeAggregateOperator.SUM,
-        parameters: [],
-      };
-    }
-    default:
-      return undefined;
-  }
-}
-
 export function _aggCol(
   colSpec: V1_ColSpec,
   column: DataCubeQuerySnapshotColumn,
@@ -179,28 +154,39 @@ export function _aggCol(
       operation: DataCubeAggregateOperator.LAST,
       parameters: [],
     };
-  } else if (matchFunctionName(func.function, DataCubeFunction.VAR_POP)) {
+  } else if (
+    matchFunctionName(func.function, DataCubeFunction.VARIANCE_POPULATION)
+  ) {
     return {
       ...column,
-      operation: DataCubeAggregateOperator.VAR_POP,
+      operation: DataCubeAggregateOperator.VARIANCE_POPULATION,
       parameters: [],
     };
-  } else if (matchFunctionName(func.function, DataCubeFunction.VAR_SAMP)) {
+  } else if (
+    matchFunctionName(func.function, DataCubeFunction.VARIANCE_SAMPLE)
+  ) {
     return {
       ...column,
-      operation: DataCubeAggregateOperator.VAR_SAMP,
+      operation: DataCubeAggregateOperator.VARIANCE_SAMPLE,
       parameters: [],
     };
-  } else if (matchFunctionName(func.function, DataCubeFunction.STDDEV_POP)) {
+  } else if (
+    matchFunctionName(
+      func.function,
+      DataCubeFunction.STANDARD_DEVIATION_POPULATION,
+    )
+  ) {
     return {
       ...column,
-      operation: DataCubeAggregateOperator.STDDEV_POP,
+      operation: DataCubeAggregateOperator.STANDARD_DEVIATION_POPULATION,
       parameters: [],
     };
-  } else if (matchFunctionName(func.function, DataCubeFunction.STDDEV_SAMP)) {
+  } else if (
+    matchFunctionName(func.function, DataCubeFunction.STANDARD_DEVIATION_SAMPLE)
+  ) {
     return {
       ...column,
-      operation: DataCubeAggregateOperator.STDDEV_SAMP,
+      operation: DataCubeAggregateOperator.STANDARD_DEVIATION_SAMPLE,
       parameters: [],
     };
   } else {