dsl-to-sql 1.0.0-fabric-1p-development.1

package/src/js-lib/db/base/CallExpressionVisitor.ts

@@ -0,0 +1,1798 @@
+/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unused-vars */
+
+import * as acorn from 'acorn';
+import { MDM_COLUMN_TYPE, ParseContext } from '../../ParseContext';
+import { VisitorInterface } from './VisitorInterface';
+import { toBinaryExpression } from '../../../sql-lib/binary_expr';
+import {
+  Binary,
+  Case,
+  ColumnRefItem,
+  ExpressionValue,
+  From,
+  Select,
+  Value,
+  ValueExpr,
+} from '../../../sql-types';
+import { PctObject } from '../../objects/PctObject';
+import { toFunction } from '../../../sql-lib/function';
+import { toWhen, WhenType } from '../../../sql-lib/when';
+import { ElseType, toElse } from '../../../sql-lib/else';
+import { toCase } from '../../../sql-lib/case';
+import { toUnaryExpression } from '../../../sql-lib/unary_expr';
+import { generateSqlQuery } from '../../../sql_query_gen';
+import { SelectBuilder, WithBuilder } from '../../../sql-lib/select';
+import { toColumn, toColumnRef } from '../../../sql-lib/column';
+import { createJsToSqlParser } from '../../JsToSqlParser';
+import { RUNTIME_TABLE_NAME } from '../../../runtime_var';
+import { toJoin } from '../../../sql-lib/join';
+import { formatDBEntityName } from '../../../utils';
+import {
+  absTransformValidator,
+  andTransformValidator,
+  averageTransformValidator,
+  averageXNegTransformValidator,
+  averageXZeroNegTransformValidator,
+  averageXZeroTransformValidator,
+  ceilTransformValidator,
+  concatenateTransformValidator,
+  dateAddTransformValidator,
+  dateDiffTransformValidator,
+  dateTransformValidator,
+  dayTransformValidator,
+  divideTransformValidator,
+  eomonthTransformValidator,
+  evenTransformValidator,
+  expTransformValidator,
+  filterIfTransformValidator,
+  floorTransformValidator,
+  fromExcelDateTransformValidator,
+  hasAllTransformValidator,
+  hasSomeTransformValidator,
+  hasTransformValidator,
+  ifTransformValidator,
+  indexOfTransformValidator,
+  inTransformValidator,
+  isEmptyTransformValidator,
+  isNumberTransformValidator,
+  leftTransformValidator,
+  lenTransformValidator,
+  logTransformValidator,
+  lowerTransformValidator,
+  matchTransformValidator,
+  maxAggregateTransformValidator,
+  medianTransformValidator,
+  midTransformValidator,
+  minAggregateTransformValidator,
+  modeTransformValidator,
+  modTransformValidator,
+  monthTransformValidator,
+  notTransformValidator,
+  nowTransformValidator,
+  numberValueTransformValidator,
+  oddTransformValidator,
+  orTransformValidator,
+  pctTransformValidator,
+  powTransformValidator,
+  randBetweenTransformValidator,
+  randTransformValidator,
+  replaceTransformValidator,
+  reptTransformValidator,
+  rightTransformValidator,
+  roundTransformValidator,
+  sqrtTransformValidator,
+  sumTransformValidator,
+  switchTransformValidator,
+  textTransformValidator,
+  todayTransformValidator,
+  trimTransformValidator,
+  upperTransformValidator,
+  uuidTransformValidator,
+  valueTransformValidator,
+  xorTransformValidator,
+  yearTransformValidator,
+} from '../validator/FormulaValidator';
+
+export const DEFAULT_FUNCTION_TRANSFORMS: Record<string, (...args: any[]) => void> = {
+  // Common functions
+  DATE: dateTransform,
+
+  // Logical functions
+  AND: andTransform,
+  IF: ifTransform,
+  OR: orTransform,
+  NOT: notTransform,
+  XOR: xorTransform,
+  IFNA: ifNullTransform,
+  HAS: hasTransform,
+  HAS_SOME: hasSomeTransform,
+  FILTERIF: filterIfTransform,
+  IN: inTransform,
+  HAS_ALL: hasAllTransform,
+  SWITCH: switchTransform,
+
+  // Date functions
+  DATEADD: dateAddTransform,
+  DATEDIFF: dateDiffTransform,
+  DAY: dayTransform,
+  EOMONTH: eomonthTransform,
+  MONTH: monthTransform,
+  NOW: nowTransform,
+  TODAY: todayTransform,
+  YEAR: yearTransform,
+  FROMEXCELDATE: fromExcelDateTransform,
+
+  // String functions
+  CONCAT: concatenateTransform,
+  CONCATENATE: concatenateTransform,
+  ISBLANK: isEmptyTransform,
+  ISEMPTY: isEmptyTransform,
+  LEFT: leftTransform,
+  LEN: lenTransform,
+  LOWER: lowerTransform,
+  MATCH: matchTransform,
+  MID: midTransform,
+  NUMBERVALUE: numberValueTransform,
+  REPLACE: replaceTransform,
+  REPT: reptTransform,
+  RIGHT: rightTransform,
+  TRIM: trimTransform,
+  TEXT: textTransform,
+  UPPER: upperTransform,
+  VALUE: valueTransform,
+  UUID: uuidTransform,
+  FIND: findTransform,
+
+  // Math functions
+  ABS: absTransform,
+  AVERAGE: averageTransform,
+  AVERAGEIF: averageIfTransform,
+  AVERAGEEXNEG: averageXNegTransform,
+  AVERAGEEXZERO: averageXZeroTransform,
+  AVERAGEEXZERONEG: averageXZeroNegTransform,
+  CEIL: ceilTransform,
+  CEILING: ceilTransform,
+  DIVIDE: divideTransform,
+  INDEXOF: indexOfTransform,
+  ISNUMBER: isNumberTransform,
+  EXP: expTransform,
+  FLOOR: floorTransform,
+  LOG: logTransform,
+  MAX: maxAggregateTransform,
+  MEDIAN: medianTransform,
+  MIN: minAggregateTransform,
+  MOD: modTransform,
+  ODD: oddTransform,
+  EVEN: evenTransform,
+  POW: powTransform,
+  PCT: pctTransform,
+  RAND: randTransform,
+  RANDBETWEEN: randBetweenTransform,
+  ROUND: roundTransform,
+  SUM: sumTransform,
+  SQRT: sqrtTransform,
+  MODE: modeTransform,
+};
+
+/**
+ * This class can be customized by extending this class and provide custom function transforms as part of `init()` implementation
+ */
+export class CallExpressionVisitor implements VisitorInterface<acorn.CallExpression> {
+  protected functionTransformMap: Map<string, (...args: any[]) => void> | undefined;
+
+  constructor() {
+    this.init();
+  }
+
+  protected init(): void {
+    this.functionTransformMap = new Map<string, (...args: any[]) => void>(
+      Object.entries(DEFAULT_FUNCTION_TRANSFORMS),
+    );
+  }
+
+  /**
+   * visitor needs to be implemented as arrow function to avoid `this` binding issue since it will be
+   * passed to `acorn-walk` library
+   */
+  public visitor = (node: acorn.CallExpression, context: ParseContext) => {
+    if (node.callee.type === 'MemberExpression') {
+      return this.processMemberExpression(node, context);
+    }
+    const fn = node.callee as acorn.Identifier;
+    const args = node.arguments.map((arg) => context.get(arg));
+    const transform = this.functionTransformMap!.get(fn.name.toUpperCase());
+    if (!transform) {
+      throw new Error(`Unsupported function: ${fn.name}`);
+    }
+    context.set(node, transform(node, context, ...args));
+  };
+
+  /**
+   * method to process call expression with member expression
+   */
+  protected processMemberExpression(node: acorn.CallExpression, context: ParseContext) {
+    const memberExpression = node.callee as acorn.MemberExpression;
+    const objectInstance = context.get(memberExpression);
+    const fnName = (memberExpression.property as acorn.Identifier).name.toUpperCase();
+    const fn = objectInstance.fnMap.get(fnName);
+    if (!fn) {
+      throw new Error(`Unsupported function: ${fnName}`);
+    }
+    const args = node.arguments.map((arg) => context.get(arg));
+    context.set(node, fn(context, ...args));
+  }
+}
+
+/**
+ * Transforms `if` call expression to `case-when-then-else` SQL expression
+ */
+export function ifTransform(
+  node: acorn.CallExpression,
+  context: ParseContext,
+  cond: Binary,
+  trueValue: ExpressionValue,
+  falseValue: ExpressionValue,
+): ExpressionValue {
+  ifTransformValidator(context, [cond, trueValue, falseValue]);
+  let whenList = [toWhen(cond, trueValue)];
+  let elseValue: ElseType | undefined = undefined;
+  if (falseValue.type == 'case') {
+    const args = (falseValue as Case).args;
+    elseValue = args.pop() as ElseType;
+    whenList = whenList.concat(args as WhenType[]);
+  } else {
+    elseValue = toElse(falseValue);
+  }
+
+  return toCase({
+    whenList,
+    elseResult: elseValue,
+  });
+}
+
+/**
+ * Transforms `today` call expression to `current_date` SQL expression
+ */
+function todayTransform(_node: acorn.CallExpression, context: ParseContext): ExpressionValue {
+  todayTransformValidator(context);
+  const sqlFnName = 'CURRENT_DATE';
+  return { type: 'sql_expr', value: sqlFnName };
+}
+
+/**
+ * Transforms `now` call expression to `current_timestamp` SQL expression
+ */
+function nowTransform(_node: acorn.CallExpression, context: ParseContext): ExpressionValue {
+  nowTransformValidator(context);
+  const sqlFnName = 'CURRENT_TIMESTAMP';
+  return { type: 'sql_expr', value: sqlFnName };
+}
+
+/**
+ * Transforms `concat` call expression to `concat` SQL expression
+ */
+function concatenateTransform(
+  _node: acorn.CallExpression,
+  context: ParseContext,
+  ...args: ExpressionValue[]
+): ExpressionValue {
+  concatenateTransformValidator(context, args);
+
+  const sqlFnName = 'CONCAT';
+  const name = { type: 'default', value: sqlFnName } as ValueExpr<string>;
+  return toFunction(name, args);
+}
+
+/**
+ * Transforms `lower` call expression to `lower` SQL expression
+ */
+function lowerTransform(
+  node: acorn.CallExpression,
+  context: ParseContext,
+  arg: ExpressionValue,
+): ExpressionValue {
+  lowerTransformValidator(context, arg);
+  const sqlFnName = 'LOWER';
+  const name = { type: 'default', value: sqlFnName } as ValueExpr<string>;
+  context.returnType = 'string';
+  return toFunction(name, [arg]);
+}
+
+/**
+ * Transforms `trim` call expression to `trim` SQL expression
+ */
+function trimTransform(
+  node: acorn.CallExpression,
+  context: ParseContext,
+  arg: ExpressionValue,
+): ExpressionValue {
+  trimTransformValidator(context, arg);
+  const sqlFnName = 'TRIM';
+  const name = { type: 'default', value: sqlFnName } as ValueExpr<string>;
+  return toFunction(name, [arg]);
+}
+
+/**
+ * Transforms `upper` call expression to `upper` SQL expression
+ */
+function upperTransform(
+  node: acorn.CallExpression,
+  context: ParseContext,
+  arg: ExpressionValue,
+): ExpressionValue {
+  upperTransformValidator(context, arg);
+  const sqlFnName = 'UPPER';
+  const name = { type: 'default', value: sqlFnName } as ValueExpr<string>;
+  return toFunction(name, [arg]);
+}
+
+/**
+ * Transforms `len` call expression to `len` SQL expression
+ */
+function lenTransform(
+  node: acorn.CallExpression,
+  context: ParseContext,
+  arg: ExpressionValue,
+): ExpressionValue {
+  lenTransformValidator(context, arg);
+  context.returnType = 'number';
+  const sqlFnName = 'LEN';
+  const name = { type: 'default', value: sqlFnName } as ValueExpr<string>;
+  return toFunction(name, [arg]);
+}
+
+/**
+ * Transforms `left` call expression to `left` SQL expression
+ */
+function leftTransform(
+  node: acorn.CallExpression,
+  context: ParseContext,
+  ...args: ExpressionValue[]
+): ExpressionValue {
+  leftTransformValidator(context, args);
+  const text = args[0];
+  const len = args[1] ?? { type: 'number', value: 0 };
+  const name = { type: 'default', value: 'LEFT' } as ValueExpr<string>;
+  return toFunction(name, [text, len]);
+}
+
+/**
+ * Transforms `right` call expression to `right` SQL expression
+ */
+function rightTransform(
+  node: acorn.CallExpression,
+  context: ParseContext,
+  ...args: ExpressionValue[]
+): ExpressionValue {
+  rightTransformValidator(context, args);
+  const sqlFnName = 'RIGHT';
+  const name = { type: 'default', value: sqlFnName } as ValueExpr<string>;
+  const text = args[0];
+  const len = args[1] ?? { type: 'number', value: 0 };
+  return toFunction(name, [text, len]);
+}
+
+/**
+ * Transforms `replace` call expression to `stuff` SQL expression
+ */
+function replaceTransform(
+  node: acorn.CallExpression,
+  context: ParseContext,
+  ...args: ExpressionValue[]
+): ExpressionValue {
+  replaceTransformValidator(context, args);
+  const sqlFnName = 'STUFF';
+  const name = { type: 'default', value: sqlFnName } as ValueExpr<string>;
+  return toFunction(name, args);
+}
+
+/**
+ * Transforms `rept` call expression to `rept` SQL expression
+ */
+function reptTransform(
+  node: acorn.CallExpression,
+  context: ParseContext,
+  ...args: ExpressionValue[]
+): ExpressionValue {
+  reptTransformValidator(context, args);
+  const sqlFnName = 'REPLICATE';
+  const name = { type: 'default', value: sqlFnName } as ValueExpr<string>;
+  return toFunction(name, args);
+}
+
+/**
+ * Transforms `match` call expression to `case-when-then-else using like in condition` SQL expression
+ */
+function matchTransform(
+  node: acorn.CallExpression,
+  context: ParseContext,
+  ...args: ExpressionValue[]
+): ExpressionValue {
+  matchTransformValidator(context, args);
+  const [value, pattern] = args;
+  return ifTransform(
+    node,
+    context,
+    { type: 'binary_expr', operator: 'LIKE', left: value, right: pattern } as Binary,
+    { type: 'string', value: 'true' } as ExpressionValue,
+    { type: 'string', value: 'false' } as ExpressionValue,
+  );
+}
+
+/**
+ * Transforms `dateadd` call expression to `DATEADD` SQL expression
+ */
+function dateAddTransform(
+  node: acorn.CallExpression,
+  context: ParseContext,
+  date: ExpressionValue,
+  numDays: ExpressionValue,
+): ExpressionValue {
+  dateAddTransformValidator(context, [date, numDays]);
+  const startDate = generateSqlQuery(date);
+  const daysToAdd = generateSqlQuery(numDays);
+  return { type: 'sql_expr', value: `DATEADD(DAY, ${daysToAdd}, ${startDate})` };
+}
+
+/**
+ * Transforms `datediff` call expression to `DATEDIFF` SQL expression
+ */
+function dateDiffTransform(
+  node: acorn.CallExpression,
+  context: ParseContext,
+  date1: ExpressionValue,
+  date2: ExpressionValue,
+): ExpressionValue {
+  dateDiffTransformValidator(context, [date1, date2]);
+  const startDate = generateSqlQuery(date1);
+  const endDate = generateSqlQuery(date2);
+  return { type: 'sql_expr', value: `DATEDIFF(DAY, ${startDate}, ${endDate})` };
+}
+
+/**
+ * Transforms `day` call expression to `day` SQL expression
+ */
+function dayTransform(
+  node: acorn.CallExpression,
+  context: ParseContext,
+  date: ExpressionValue,
+): ExpressionValue {
+  dayTransformValidator(context, date);
+  const sqlFnName = 'DAY';
+  const name = { type: 'default', value: sqlFnName } as ValueExpr<string>;
+  return toFunction(name, [date]);
+}
+
+/**
+ * Transforms `month` call expression to `month` SQL expression
+ */
+function monthTransform(
+  node: acorn.CallExpression,
+  context: ParseContext,
+  date: ExpressionValue,
+): ExpressionValue {
+  monthTransformValidator(context, date);
+  const sqlFnName = 'MONTH';
+  const name = { type: 'default', value: sqlFnName } as ValueExpr<string>;
+  return toFunction(name, [date]);
+}
+
+/**
+ * Transforms `year` call expression to `year` SQL expression
+ */
+function yearTransform(
+  node: acorn.CallExpression,
+  context: ParseContext,
+  date: ExpressionValue,
+): ExpressionValue {
+  yearTransformValidator(context, date);
+  const sqlFnName = 'YEAR';
+  const name = { type: 'default', value: sqlFnName } as ValueExpr<string>;
+  return toFunction(name, [date]);
+}
+
+/**
+ * Transforms `eomonth` call expression to `eomonth` SQL expression
+ */
+function eomonthTransform(
+  node: acorn.CallExpression,
+  context: ParseContext,
+  ...args: ExpressionValue[]
+): ExpressionValue {
+  eomonthTransformValidator(context, args);
+  const sqlFnName = 'EOMONTH';
+  const name = { type: 'default', value: sqlFnName } as ValueExpr<string>;
+  if (args.length < 1 || args.length > 2) {
+    throw new Error('EOMONTH() requires 1 or 2 arguments');
+  }
+  return toFunction(name, args);
+}
+
+/**
+ * Transforms `divide` call expression to `divide` SQL expression
+ */
+function divideTransform(
+  node: acorn.CallExpression,
+  context: ParseContext,
+  dividend: ExpressionValue,
+  divisor: ExpressionValue,
+): ExpressionValue {
+  divideTransformValidator(context, [dividend, divisor]);
+  const cast = (expr: ExpressionValue) =>
+    toFunction({ type: 'default', value: 'CAST' }, [
+      toBinaryExpression('AS', expr, { type: 'default', value: 'FLOAT' }),
+    ]);
+
+  const zeroCheck = toBinaryExpression('=', cast(divisor), { type: 'number', value: 0 });
+  const whenArg = toWhen(zeroCheck, { type: 'null', value: null });
+  const elseArg = toElse(toBinaryExpression('/', cast(dividend), cast(divisor)));
+
+  return toCase({ whenList: [whenArg], elseResult: elseArg });
+}
+
+/**
+ * Transforms `and` call expression to `and` SQL expression
+ */
+function andTransform(
+  node: acorn.CallExpression,
+  context: ParseContext,
+  ...conds: ExpressionValue[]
+): ExpressionValue {
+  andTransformValidator(context, conds);
+  const sqlOperator = 'AND';
+  const [first, ...rest] = conds;
+  const condition = rest.reduce((acc, cond) => {
+    return toBinaryExpression(sqlOperator, acc, cond);
+  }, first);
+
+  if (!context.ifCondition) {
+    return ifTransform(
+      node,
+      context,
+      condition as Binary,
+      { type: 'string', value: 'true' },
+      { type: 'string', value: 'false' },
+    );
+  }
+
+  return condition;
+}
+/**
+ * Transforms `or` call expression to `or` SQL expression
+ */
+function orTransform(
+  node: acorn.CallExpression,
+  context: ParseContext,
+  ...conds: ExpressionValue[]
+): ExpressionValue {
+  orTransformValidator(context, conds);
+  const sqlOperator = 'OR';
+  const [first, ...rest] = conds;
+  const condition = rest.reduce((acc, cond) => {
+    return toBinaryExpression(sqlOperator, acc, cond);
+  }, first);
+
+  if (!context.ifCondition) {
+    return ifTransform(
+      node,
+      context,
+      condition as Binary,
+      { type: 'string', value: 'true' },
+      { type: 'string', value: 'false' },
+    );
+  }
+
+  return condition;
+}
+
+/**
+ * Transforms `ceil` call expression to `ceil` SQL expression
+ */
+function ceilTransform(
+  node: acorn.CallExpression,
+  context: ParseContext,
+  arg: ExpressionValue,
+): ExpressionValue {
+  ceilTransformValidator(context, arg);
+  const sqlFnName = 'CEILING';
+  const name = { type: 'default', value: sqlFnName } as ValueExpr<string>;
+  return toFunction(name, [arg]);
+}
+
+/**
+ * Transforms `floor` call expression to `floor` SQL expression
+ */
+function floorTransform(
+  node: acorn.CallExpression,
+  context: ParseContext,
+  arg: ExpressionValue,
+): ExpressionValue {
+  floorTransformValidator(context, arg);
+  const sqlFnName = 'FLOOR';
+  const name = { type: 'default', value: sqlFnName } as ValueExpr<string>;
+  return toFunction(name, [arg]);
+}
+
+/**
+ * Transforms `abs` call expression to `abs` SQL expression
+ */
+function absTransform(
+  node: acorn.CallExpression,
+  context: ParseContext,
+  arg: ExpressionValue,
+): ExpressionValue {
+  absTransformValidator(context, arg);
+  const sqlFnName = 'ABS';
+  const name = { type: 'default', value: sqlFnName } as ValueExpr<string>;
+  return toFunction(name, [arg]);
+}
+
+/**
+ * Transforms `round` call expression to `round` SQL expression
+ */
+function roundTransform(
+  node: acorn.CallExpression,
+  context: ParseContext,
+  ...args: ExpressionValue[]
+): ExpressionValue {
+  roundTransformValidator(context, args);
+
+  const sqlFnName = 'ROUND';
+  const name = { type: 'default', value: sqlFnName } as ValueExpr<string>;
+  const [value, decimals] = args;
+  return toFunction(name, [value, decimals ?? { type: 'number', value: 0 }]);
+}
+
+/**
+ * Transforms `exp` call expression to `exp` SQL expression
+ */
+function expTransform(
+  node: acorn.CallExpression,
+  context: ParseContext,
+  arg: ExpressionValue,
+): ExpressionValue {
+  expTransformValidator(context, arg);
+  const sqlFnName = 'EXP';
+  const name = { type: 'default', value: sqlFnName } as ValueExpr<string>;
+  return toFunction(name, [arg]);
+}
+
+/**
+ * Transforms `pow` call expression to `pow` SQL expression
+ */
+function powTransform(
+  node: acorn.CallExpression,
+  context: ParseContext,
+  ...args: ExpressionValue[]
+): ExpressionValue {
+  powTransformValidator(context, args);
+  const sqlFnName = 'POWER';
+  const name = { type: 'default', value: sqlFnName } as ValueExpr<string>;
+  if (args.length < 2) {
+    throw new Error('POW() requires 2 arguments');
+  }
+  return toFunction(name, args);
+}
+
+/**
+ * Transforms `log` call expression to `log` SQL expression
+ */
+function logTransform(
+  node: acorn.CallExpression,
+  context: ParseContext,
+  ...args: ExpressionValue[]
+): ExpressionValue {
+  logTransformValidator(context, args);
+  const sqlFnName = 'LOG';
+  const name = { type: 'default', value: sqlFnName } as ValueExpr<string>;
+  if (args.length < 1 || args.length > 2) {
+    throw new Error('LOG() requires 1 or 2 arguments');
+  }
+  return toFunction(name, args);
+}
+
+/**
+ * Transforms `sqrt` call expression to `sqrt` SQL expression
+ */
+function sqrtTransform(
+  node: acorn.CallExpression,
+  context: ParseContext,
+  arg: ExpressionValue,
+): ExpressionValue {
+  sqrtTransformValidator(context, arg);
+  const sqlFnName = 'SQRT';
+  const name = { type: 'default', value: sqlFnName } as ValueExpr<string>;
+  return toFunction(name, [arg]);
+}
+
+/**
+ * Transforms `mod` call expression to `mod` SQL expression
+ */
+function modTransform(
+  node: acorn.CallExpression,
+  context: ParseContext,
+  ...args: ExpressionValue[]
+): ExpressionValue {
+  modeTransformValidator(context, args);
+  const [dividend, divisor] = args;
+  return toBinaryExpression('%', dividend, divisor);
+}
+
+/**
+ * Transforms `not` call expression to `not` SQL expression
+ */
+function notTransform(
+  node: acorn.CallExpression,
+  context: ParseContext,
+  arg: Binary,
+): ExpressionValue {
+  notTransformValidator(context, arg);
+  if (!context.ifCondition) {
+    const whenArg = toWhen(
+      arg,
+      toFunction({ type: 'default', value: 'CAST' }, [
+        toBinaryExpression('AS', { type: 'number', value: 0 }, { type: 'default', value: 'BIT' }),
+      ]),
+    );
+    const elseArg = toElse(
+      toFunction({ type: 'default', value: 'CAST' }, [
+        toBinaryExpression('AS', { type: 'number', value: 1 }, { type: 'default', value: 'BIT' }),
+      ]),
+    );
+    return toCase({ whenList: [whenArg], elseResult: elseArg });
+  }
+  return arg;
+}
+
+/**
+ * Transforms `rand` call expression to `rand` SQL expression
+ */
+function randTransform(node: acorn.CallExpression, context: ParseContext): ExpressionValue {
+  randTransformValidator(context);
+  const sqlFnName = 'RAND';
+  const name = { type: 'default', value: sqlFnName } as ValueExpr<string>;
+  return toFunction(name, []);
+}
+
+/**
+ * Transforms `randbetween` call expression to `rand_between` SQL expression
+ */
+function randBetweenTransform(
+  node: acorn.CallExpression,
+  context: ParseContext,
+  ...args: ExpressionValue[]
+): ExpressionValue {
+  randBetweenTransformValidator(context, args);
+  const [minValue, maxValue] = args.map(generateSqlQuery);
+  return { type: 'sql_expr', value: `(RAND() * (${maxValue} - ${minValue}) + ${minValue})` };
+}
+
+/**
+ * Transforms `average` call expression to SQL expression. This performs average of the arguments
+ * which is different than SQL's AVG() function.
+ */
+function averageTransform(
+  node: acorn.CallExpression,
+  context: ParseContext,
+  ...args: ExpressionValue[]
+): ExpressionValue {
+  averageTransformValidator(context, args);
+  const argsCount = args.length;
+  const argList = args.map((arg) => `COALESCE(${generateSqlQuery(arg)}, 0)`);
+  return { type: 'sql_expr', value: `CAST(((${argList.join(' + ')})/${argsCount}) AS FLOAT)` };
+}
+
+function averageConditionalTransform(
+  node: acorn.CallExpression,
+  context: ParseContext,
+  valueList: ExpressionValue[],
+  conditionBuilder: (valueColumnName: string) => Binary,
+): Select {
+  const currentColumnId = context.currentColumnId;
+  const valueColumnName = `val_${currentColumnId}`;
+  const unionCte = new WithBuilder(context)
+    .addName(`cte_union_${currentColumnId}`)
+    .addStmt(
+      valueList.reverse().reduce(
+        (acc, arg) => {
+          const builder = new SelectBuilder()
+            .addColumns([
+              ...context.primaryKeyColumns.map((id) => toColumn(toColumnRef(id))),
+              toColumn(arg, valueColumnName),
+            ])
+            .addFrom([{ type: 'from', table: RUNTIME_TABLE_NAME } as From]);
+
+          if (acc) {
+            builder.addSetOp('UNION ALL').addNext(acc);
+          }
+          return builder.build();
+        },
+        undefined as Select | undefined,
+      )!,
+    )
+    .build();
+
+  const filterCte = new WithBuilder(context)
+    .addName(`cte_filter_${currentColumnId}`)
+    .addStmt(
+      new SelectBuilder()
+        .addColumns([
+          ...context.primaryKeyColumns.map((id) => toColumn(toColumnRef(id))),
+          toColumn(toColumnRef(valueColumnName)),
+        ])
+        .addFrom([{ type: 'from', table: unionCte.name.value } as From])
+        .addWhere(conditionBuilder(valueColumnName))
+        .build(),
+    )
+    .build();
+
+  const avgCte = new WithBuilder(context)
+    .addName(`cte_avg_${currentColumnId}`)
+    .addStmt(
+      new SelectBuilder()
+        .addColumns([
+          ...context.primaryKeyColumns.map((id) => toColumn(toColumnRef(id))),
+          toColumn(
+            toFunction({ type: 'default', value: 'AVG' }, [toColumnRef(valueColumnName)]),
+            currentColumnId,
+          ),
+        ])
+        .addFrom([{ type: 'from', table: filterCte.name.value } as From])
+        .addGroupby({
+          columns: context.primaryKeyColumns.map((id) => toColumnRef(id)),
+          modifiers: [],
+        })
+        .build(),
+    )
+    .build();
+
+  const finalCte = new WithBuilder(context)
+    .addName(`cte_${currentColumnId}`)
+    .addStmt(
+      new SelectBuilder()
+        .addColumns([
+          toColumn(toColumnRef('*', RUNTIME_TABLE_NAME)),
+          toColumn(toColumnRef(currentColumnId)),
+        ])
+        .addFrom([
+          { type: 'from', table: RUNTIME_TABLE_NAME } as From,
+          toJoin(
+            'INNER JOIN',
+            avgCte.name.value,
+            context.primaryKeyColumns
+              .map((id) =>
+                toBinaryExpression(
+                  '=',
+                  toColumnRef(id, RUNTIME_TABLE_NAME),
+                  toColumnRef(id, avgCte.name.value),
+                ),
+              )
+              .reduce((acc, expr) => toBinaryExpression('AND', acc, expr)),
+          ),
+        ])
+        .build(),
+    )
+    .build();
+
+  // since this transformation depends on primary key columns, manually add primary columns to the dependencies
+  context.primaryKeyColumns.forEach((id) => context.addColumnDep(id));
+  const select = new SelectBuilder().addWith([unionCte, filterCte, avgCte, finalCte]).build();
+  return select;
+}
+
+/**
+ * Transforms `averageif` call expression to SQL expression. This performs average of the arguments
+ * which is different than SQL's AVG() function.
+ */
+function averageIfTransform(
+  node: acorn.CallExpression,
+  context: ParseContext,
+  valueList: ExpressionValue[],
+  condition: ExpressionValue,
+): Select {
+  const conditionBuilder = (valueColumnName: string) => {
+    if (condition.type === 'string') {
+      const conditionWithLhs = `${valueColumnName} ${condition.value}`;
+      const localContext = new ParseContext({
+        columnConfigMap: {
+          ...context.columnConfigMap,
+          [valueColumnName]: {
+            columnName: valueColumnName,
+            columnType: MDM_COLUMN_TYPE.NUMBER,
+            columnMeta: { tableName: context.tableName },
+          },
+        },
+        currentColumnId: context.currentColumnId,
+        primaryKeyColumns: context.primaryKeyColumns,
+        tableName: context.tableName,
+      });
+      const parser = createJsToSqlParser(localContext);
+      return parser.parse(conditionWithLhs);
+    }
+    throw new Error('Invalid condition type');
+  };
+  return averageConditionalTransform(node, context, valueList, conditionBuilder);
+}
+
+/**
+ * Transforms `averagexneg` call expression to SQL expression. This performs average of the arguments
+ * which is different than SQL's AVG() function.
+ */
+function averageXNegTransform(
+  node: acorn.CallExpression,
+  context: ParseContext,
+  valueList: ExpressionValue[],
+): Select {
+  averageXNegTransformValidator(context, valueList);
+  const conditionBuilder = (valueColumnName: string) => {
+    return toBinaryExpression('>=', toColumnRef(valueColumnName), { type: 'number', value: 0 });
+  };
+  return averageConditionalTransform(node, context, valueList, conditionBuilder);
+}
+
+/**
+ * Transforms `averagexzero` call expression to SQL expression. This performs average of the arguments
+ * which is different than SQL's AVG() function.
+ */
+function averageXZeroTransform(
+  node: acorn.CallExpression,
+  context: ParseContext,
+  valueList: ExpressionValue[],
+): Select {
+  averageXZeroTransformValidator(context, valueList);
+  const conditionBuilder = (valueColumnName: string) => {
+    return toBinaryExpression('!=', toColumnRef(valueColumnName), { type: 'number', value: 0 });
+  };
+  return averageConditionalTransform(node, context, valueList, conditionBuilder);
+}
+
+/**
+ * Transforms `averagexzeroneg` call expression to SQL expression. This performs average of the arguments
+ * which is different than SQL's AVG() function.
+ */
+function averageXZeroNegTransform(
+  node: acorn.CallExpression,
+  context: ParseContext,
+  valueList: ExpressionValue[],
+): Select {
+  averageXZeroNegTransformValidator(context, valueList);
+  const conditionBuilder = (valueColumnName: string) => {
+    return toBinaryExpression('>', toColumnRef(valueColumnName), { type: 'number', value: 0 });
+  };
+  return averageConditionalTransform(node, context, valueList, conditionBuilder);
+}
+
+/**
+ * Transforms `numbervalue` call expression to SQL expression.
+ */
+function numberValueTransform(
+  node: acorn.CallExpression,
+  context: ParseContext,
+  ...args: ExpressionValue[]
+): ExpressionValue {
+  numberValueTransformValidator(context, args);
+  const [valueToCast, decimalSeparator, thousandSeparator] = args;
+  let expr = generateSqlQuery(valueToCast);
+  if (thousandSeparator) {
+    expr = `REPLACE(${expr}, '${generateSqlQuery(thousandSeparator)}', '')`;
+  }
+  if (decimalSeparator) {
+    expr = `REPLACE(${expr}, '${generateSqlQuery(decimalSeparator)}', '.')`;
+  }
+  return { type: 'sql_expr', value: `CAST(${expr} AS FLOAT)` };
+}
+
+/**
+ * Transforms `odd` call expression to SQL expression.
+ *
+ * Sql Expression:
+ * CASE WHEN arg % 2 = 1 THEN arg
+ *      ELSE arg + 1
+ * END
+ */
+function oddTransform(
+  node: acorn.CallExpression,
+  context: ParseContext,
+  arg: ExpressionValue,
+): ExpressionValue {
+  oddTransformValidator(context, arg);
+  const moduloCondition = toBinaryExpression('%', arg, { type: 'number', value: 2 });
+  const isOdd = toBinaryExpression('=', moduloCondition, { type: 'number', value: 1 });
+  const whenArg = toWhen(isOdd, arg);
+  const elseArg = toElse(toBinaryExpression('+', arg, { type: 'number', value: 1 }));
+  return toCase({ whenList: [whenArg], elseResult: elseArg });
+}
+
+/**
+ * Transforms `even` call expression to SQL expression.
+ *
+ * Sql Expression:
+ * CASE WHEN arg % 2 = 0 THEN arg
+ *      ELSE arg + 1
+ * END
+ */
+function evenTransform(
+  node: acorn.CallExpression,
+  context: ParseContext,
+  ...args: ExpressionValue[]
+): ExpressionValue {
+  if (args.length !== 1) {
+    throw new Error('EVEN() requires 1 argument');
+  }
+
+  const arg = args[0];
+  const sqlFnName = 'FLOOR';
+  const name = { type: 'default', value: sqlFnName } as ValueExpr<string>;
+  const floored = toFunction(name, [arg]);
+
+  const intCast = toFunction({ type: 'default', value: 'CAST' }, [
+    toBinaryExpression('AS', floored, { type: 'default', value: 'INT' }),
+  ]);
+
+  const moduloCondition = toBinaryExpression('%', intCast, { type: 'number', value: 2 });
+  const isEven = toBinaryExpression('=', moduloCondition, { type: 'number', value: 0 });
+
+  const whenArg = toWhen(isEven, intCast);
+  const elseArg = toElse(toBinaryExpression('+', intCast, { type: 'number', value: 1 }));
+
+  return toCase({ whenList: [whenArg], elseResult: elseArg });
+}
+
+/**
+ * Transforms `IN(column, [value1, value2, ...])` call expression to SQL CASE expression.
+ *
+ * SQL:
+ * CASE
+ *   WHEN column IN ('val1', 'val2', ...) THEN TRUE
+ *   ELSE FALSE
+ * END
+ */
+function inTransform(
+  node: acorn.CallExpression,
+  context: ParseContext,
+  ...args: ExpressionValue[]
+): ExpressionValue {
+  inTransformValidator(context, args);
+  const [column, values] = args;
+  const inExpr: ExpressionValue = {
+    type: 'binary_expr',
+    operator: 'IN',
+    left: column,
+    right: {
+      type: 'expr_list',
+      value: values,
+    },
+  };
+
+  const whenClause = toWhen(inExpr, { type: 'number', value: 1 });
+  const elseClause = toElse({ type: 'number', value: 0 });
+
+  return toCase({
+    whenList: [whenClause],
+    elseResult: elseClause,
+  });
+}
+
+/**
+ * Transforms `sum` call expression to SQL expression.
+ */
+function sumTransform(
+  node: acorn.CallExpression,
+  context: ParseContext,
+  ...args: ExpressionValue[]
+): ExpressionValue {
+  sumTransformValidator(context, args);
+  const argList = args.map((arg) => `COALESCE(${generateSqlQuery(arg)}, 0)`);
+  return { type: 'sql_expr', value: `(${argList.join(' + ')})` };
+}
+
+/**
+ * Transforms `indexof` call expression to SQL expression.
+ */
+function indexOfTransform(
+  node: acorn.CallExpression,
+  context: ParseContext,
+  valueList: ExpressionValue[],
+  valueToFind: ExpressionValue,
+): ExpressionValue {
+  indexOfTransformValidator(context, valueList, valueToFind);
+  const whenList = valueList.map((value, index) =>
+    toWhen(toBinaryExpression('=', value, valueToFind), { type: 'number', value: index }),
+  );
+  return toCase({ whenList, elseResult: toElse({ type: 'number', value: -1 }) });
+}
+
+/**
+ * Transforms `isblank` call expression to SQL expression.
+ */
+function isEmptyTransform(
+  node: acorn.CallExpression,
+  context: ParseContext,
+  arg: ExpressionValue,
+): ExpressionValue {
+  isEmptyTransformValidator(context, arg);
+  const condition = toBinaryExpression('IS', arg, { type: 'null', value: null });
+
+  if (!context.ifCondition) {
+    const whenArg = toWhen(
+      condition,
+      toFunction({ type: 'default', value: 'CAST' }, [
+        toBinaryExpression('AS', { type: 'number', value: 1 }, { type: 'default', value: 'BIT' }),
+      ]),
+    );
+
+    const elseArg = toElse(
+      toFunction({ type: 'default', value: 'CAST' }, [
+        toBinaryExpression('AS', { type: 'number', value: 0 }, { type: 'default', value: 'BIT' }),
+      ]),
+    );
+
+    return toCase({ whenList: [whenArg], elseResult: elseArg });
+  }
+
+  return condition;
+}
+
+/**
+ * Transforms `isnumber` call expression to SQL expression.
+ */
+function isNumberTransform(
+  node: acorn.CallExpression,
+  context: ParseContext,
+  arg: ExpressionValue,
+): ExpressionValue {
+  isNumberTransformValidator(context, arg);
+  const sqlFnName = 'ISNUMERIC';
+  const name = { type: 'default', value: sqlFnName } as ValueExpr<string>;
+  return toFunction(name, [arg]);
+}
+
+/**
+ * Transforms `MAX` call expression to aggregate `MAX` SQL expression
+ */
+function maxAggregateTransform(
+  node: acorn.CallExpression,
+  context: ParseContext,
+  ...args: ExpressionValue[]
+): ExpressionValue {
+  maxAggregateTransformValidator(context, args);
+  const sqlFnName = 'GREATEST';
+  const name = { type: 'default', value: sqlFnName } as ValueExpr<string>;
+  return toFunction(name, args);
+}
+
+/**
+ * Transforms `MIN` call expression to aggregate `MIN` SQL expression
+ */
+function minAggregateTransform(
+  node: acorn.CallExpression,
+  context: ParseContext,
+  ...args: ExpressionValue[]
+): ExpressionValue {
+  minAggregateTransformValidator(context, args);
+  const sqlFnName = 'LEAST';
+  const name = { type: 'default', value: sqlFnName } as ValueExpr<string>;
+  return toFunction(name, args);
+}
+
+/**
+ * Transforms `mid` call expression to SQL expression.
+ */
+function midTransform(
+  node: acorn.CallExpression,
+  context: ParseContext,
+  ...args: ExpressionValue[]
+): ExpressionValue {
+  midTransformValidator(context, args);
+  const sqlFnName = 'SUBSTRING';
+  const name = { type: 'default', value: sqlFnName } as ValueExpr<string>;
+  if (args.length !== 3) {
+    throw new Error('MID() requires 3 arguments');
+  }
+  return toFunction(name, args);
+}
+
+/**
+ * Transforms `median` call expression to SQL expression.
+ */
+function medianTransform(
+  node: acorn.CallExpression,
+  context: ParseContext,
+  ...args: ExpressionValue[]
+): Select {
+  medianTransformValidator(context, args);
+  const currentColumnId = context.currentColumnId;
+  const valueColumnName = formatDBEntityName(`val_${currentColumnId}`);
+  const unionName = formatDBEntityName(`cte_union_${currentColumnId}`);
+  const unionCte = new WithBuilder(context)
+    .addName(unionName)
+    .addStmt(
+      args.reverse().reduce(
+        (acc, arg) => {
+          const builder = new SelectBuilder()
+            .addColumns([
+              ...context.primaryKeyColumns.map((id) => toColumn(toColumnRef(id))),
+              toColumn(arg, valueColumnName),
+            ])
+            .addFrom([{ type: 'from', table: RUNTIME_TABLE_NAME } as From]);
+
+          if (acc) {
+            builder.addSetOp('UNION ALL').addNext(acc);
+          }
+          return builder.build();
+        },
+        undefined as Select | undefined,
+      )!,
+    )
+    .build();
+
+  const aggName = formatDBEntityName(`cte_agg_${currentColumnId}`);
+  const aggCte = new WithBuilder(context)
+    .addName(aggName)
+    .addStmt(
+      new SelectBuilder()
+        .addDistinct()
+        .addColumns([
+          ...context.primaryKeyColumns.map((id) => toColumn(toColumnRef(id))),
+          toColumn(
+            {
+              type: 'sql_expr',
+              value: `PERCENTILE_CONT(0.50) WITHIN GROUP(ORDER BY ${valueColumnName}) OVER (PARTITION BY ${context.primaryKeyColumns.map((id) => id).join(', ')})`,
+            },
+            currentColumnId,
+          ),
+        ])
+        .addFrom([{ type: 'from', table: unionCte.name.value } as From])
+        .build(),
+    )
+    .build();
+
+  const finalCteName = formatDBEntityName(`cte_${currentColumnId}`);
+  const finalCte = new WithBuilder(context)
+    .addName(finalCteName)
+    .addStmt(
+      new SelectBuilder()
+        .addColumns([
+          toColumn(toColumnRef('*', RUNTIME_TABLE_NAME)),
+          toColumn(toColumnRef(currentColumnId)),
+        ])
+        .addFrom([
+          { type: 'from', table: RUNTIME_TABLE_NAME } as From,
+          toJoin(
+            'INNER JOIN',
+            aggCte.name.value,
+            context.primaryKeyColumns
+              .map((id) =>
+                toBinaryExpression(
+                  '=',
+                  toColumnRef(id, RUNTIME_TABLE_NAME),
+                  toColumnRef(id, aggCte.name.value),
+                ),
+              )
+              .reduce((acc, expr) => toBinaryExpression('AND', acc, expr)),
+          ),
+        ])
+        .build(),
+    )
+    .build();
+
+  // since this transformation depends on primary key columns, manually add primary columns to the dependencies
+  context.primaryKeyColumns.forEach((id) => context.addColumnDep(id));
+  const select = new SelectBuilder().addWith([unionCte, aggCte, finalCte]).build();
+  return select;
+}
+
+/**
+ * Transforms `MODE` call expression to SQL expression.
+ */
+function modeTransform(
+  node: acorn.CallExpression,
+  context: ParseContext,
+  ...args: ExpressionValue[]
+): Select {
+  modeTransformValidator(context, args);
+  const currentColumnId = context.currentColumnId;
+  const valueColumnName = `val_${currentColumnId}`;
+  const freqColumn = `freq_${currentColumnId}`;
+  const rankColumn = `rank_${currentColumnId}`;
+
+  // Step 1: Union CTE
+  const unionCte = new WithBuilder(context)
+    .addName(`cte_union_${currentColumnId}`)
+    .addStmt(
+      args.reverse().reduce(
+        (acc, arg) => {
+          const builder = new SelectBuilder()
+            .addColumns([
+              ...context.primaryKeyColumns.map((id) => toColumn(toColumnRef(id))),
+              toColumn(arg, valueColumnName),
+            ])
+            .addFrom([
+              {
+                type: 'from',
+                db: null,
+                schema: undefined,
+                table: RUNTIME_TABLE_NAME,
+                as: null,
+              },
+            ]);
+
+          if (acc) {
+            builder.addSetOp('UNION ALL').addNext(acc);
+          }
+
+          return builder.build();
+        },
+        undefined as Select | undefined,
+      )!,
+    )
+    .build();
+
+  // Step 2: Frequency CTE
+  const freqCte = new WithBuilder(context)
+    .addName(`cte_freq_${currentColumnId}`)
+    .addStmt(
+      new SelectBuilder()
+        .addColumns([
+          ...context.primaryKeyColumns.map((id) => toColumn(toColumnRef(id))),
+          toColumn(toColumnRef(valueColumnName), valueColumnName),
+          toColumn(
+            {
+              type: 'sql_expr',
+              value: `COUNT(*) OVER (PARTITION BY ${context.primaryKeyColumns.join(', ')}, ${valueColumnName})`,
+            },
+            freqColumn,
+          ),
+        ])
+        .addFrom([
+          {
+            type: 'from',
+            db: null,
+            schema: undefined,
+            table: `cte_union_${currentColumnId}`,
+            as: null,
+          },
+        ])
+        .build(),
+    )
+    .build();
+
+  // Step 3: Ranked CTE
+  const rankedCte = new WithBuilder(context)
+    .addName(`cte_ranked_${currentColumnId}`)
+    .addStmt(
+      new SelectBuilder()
+        .addColumns([
+          ...context.primaryKeyColumns.map((id) => toColumn(toColumnRef(id))),
+          toColumn(toColumnRef(valueColumnName), valueColumnName),
+          toColumn(
+            {
+              type: 'sql_expr',
+              value: `ROW_NUMBER() OVER (PARTITION BY ${context.primaryKeyColumns.join(', ')} ORDER BY ${freqColumn} DESC)`,
+            },
+            rankColumn,
+          ),
+        ])
+        .addFrom([
+          {
+            type: 'from',
+            db: null,
+            schema: undefined,
+            table: `cte_freq_${currentColumnId}`,
+            as: null,
+          },
+        ])
+        .build(),
+    )
+    .build();
+
+  // Step 4: Mode CTE (where rank = 1)
+  const modeCte = new WithBuilder(context)
+    .addName(`cte_mode_${currentColumnId}`)
+    .addStmt(
+      new SelectBuilder()
+        .addColumns([
+          ...context.primaryKeyColumns.map((id) => toColumn(toColumnRef(id))),
+          toColumn(toColumnRef(valueColumnName)),
+        ])
+        .addFrom([
+          {
+            type: 'from',
+            db: null,
+            schema: undefined,
+            table: `cte_ranked_${currentColumnId}`,
+            as: null,
+          },
+        ])
+        .addWhere({
+          type: 'binary_expr',
+          operator: '=',
+          left: toColumnRef(rankColumn),
+          right: { type: 'number', value: 1 },
+        })
+        .build(),
+    )
+    .build();
+
+  // Step 5: Final CTE (Join runtime table with mode)
+  const finalCte = new WithBuilder(context)
+    .addName(`cte_${currentColumnId}`)
+    .addStmt(
+      new SelectBuilder()
+        .addColumns([
+          toColumn(toColumnRef('*', RUNTIME_TABLE_NAME)),
+          toColumn(toColumnRef(valueColumnName, `cte_mode_${currentColumnId}`), currentColumnId),
+        ])
+        .addFrom([
+          {
+            type: 'from',
+            table: RUNTIME_TABLE_NAME,
+          } as From,
+          toJoin(
+            'INNER JOIN',
+            `cte_mode_${currentColumnId}`,
+            context.primaryKeyColumns
+              .map((id) =>
+                toBinaryExpression(
+                  '=',
+                  toColumnRef(id, RUNTIME_TABLE_NAME),
+                  toColumnRef(id, `cte_mode_${currentColumnId}`),
+                ),
+              )
+              .reduce((acc, expr) => (acc ? toBinaryExpression('AND', acc, expr) : expr))!,
+          ),
+        ])
+        .build(),
+    )
+    .build();
+  context.primaryKeyColumns.forEach((id) => context.addColumnDep(id));
+
+  // Final SELECT with all CTEs
+  return new SelectBuilder().addWith([unionCte, freqCte, rankedCte, modeCte, finalCte]).build();
+}
+
+/**
+ * Transforms `value` call expression to SQL expression.
+ */
+function valueTransform(
+  node: acorn.CallExpression,
+  context: ParseContext,
+  arg: ExpressionValue,
+): ExpressionValue {
+  valueTransformValidator(context, arg);
+  const sqlFnName = 'CAST';
+  const name = { type: 'default', value: sqlFnName } as ValueExpr<string>;
+  return toFunction(name, [toBinaryExpression('AS', arg, { type: 'default', value: 'FLOAT' })]);
+}
+
+/**
+ * Transforms `pct` call expression to SQL expression.
+ */
+function pctTransform(
+  node: acorn.CallExpression,
+  context: ParseContext,
+  arg: ExpressionValue,
+): PctObject {
+  pctTransformValidator(context, arg);
+  return new PctObject(arg);
+}
+
+/**
+ * Transforms `xor` call expression to SQL expression.
+ */
+function xorTransform(
+  node: acorn.CallExpression,
+  context: ParseContext,
+  ...args: ExpressionValue[]
+): ExpressionValue {
+  xorTransformValidator(context, args);
+  const [arg1, arg2] = args;
+  const notArg2 = toUnaryExpression('NOT', arg2);
+  const andLeft = toBinaryExpression('AND', arg1, notArg2);
+
+  const notArg1 = toUnaryExpression('NOT', arg1);
+  const andRight = toBinaryExpression('AND', notArg1, arg2);
+
+  // Combining with OR: (arg1 AND NOT arg2) OR (NOT arg1 AND arg2)
+  const xorCondition = toBinaryExpression('OR', andLeft, andRight);
+
+  const whenArg = toWhen(xorCondition, { type: 'bit', value: 1 });
+  const elseArg = toElse({ type: 'bit', value: 0 });
+
+  return toCase({ whenList: [whenArg], elseResult: elseArg });
+}
+
+/**
+ * Transforms `text` call expression to SQL expression.
+ */
+function textTransform(
+  node: acorn.CallExpression,
+  context: ParseContext,
+  ...args: ExpressionValue[]
+): ExpressionValue {
+  textTransformValidator(context, args);
+  const sqlFnName = 'FORMAT';
+  const name = { type: 'default', value: sqlFnName } as ValueExpr<string>;
+  const [value, format, locale = { type: 'string', value: 'en-US' }] = args;
+  const formatPattern = (format as Value).value as string;
+  let resolvedPatternExp = format;
+  if (!formatPattern.includes('#') && !formatPattern.includes('%')) {
+    resolvedPatternExp = { type: 'string', value: datePattern(formatPattern) };
+  }
+  return toFunction(name, [value, resolvedPatternExp, locale]);
+}
+
+export function datePattern(formatPattern: string): string {
+  // https://learn.microsoft.com/en-us/dotnet/standard/base-types/custom-date-and-time-format-strings
+  const patterns: Record<string, string> = {
+    yyyy: 'yyyy',
+    yyy: 'yyyy',
+    yy: 'yy',
+    y: 'y',
+    mmmm: 'MMMM',
+    mmm: 'MMM',
+    mm: 'MM',
+    m: '%M',
+    dddd: 'dddd',
+    ddd: 'ddd',
+    dd: 'dd',
+    d: '%d',
+  };
+
+  if (patterns[formatPattern]) {
+    return patterns[formatPattern];
+  }
+
+  // Convert date format patterns to their SQL equivalents
+  return formatPattern.replace(/[dmy]{1,4}/g, (match: string) => {
+    if (patterns[match]) {
+      return patterns[match];
+    }
+    throw new Error(`Invalid date format pattern: ${match}`); // this should never happen unless the regex and pattern map are inconsistent
+  });
+}
+
+/**
+ * Transforms `uuid` call expression to `NEWID()` SQL expression
+ */
+function uuidTransform(_node: acorn.CallExpression, context: ParseContext): ExpressionValue {
+  uuidTransformValidator(context);
+  const sqlFnName = 'NEWID()';
+  return { type: 'sql_expr', value: sqlFnName };
+}
+
+/**
+ * Transforms `IFNA` call expression to SQL expression.
+ */
+function ifNullTransform(
+  node: acorn.CallExpression,
+  context: ParseContext,
+  ...args: ExpressionValue[]
+): ExpressionValue {
+  const argsCount = args.length;
+  if (argsCount < 2) {
+    throw new Error('IFNA() requires 2 arguments');
+  }
+  const [value, fallback] = args;
+  const response = toFunction({ type: 'default', value: 'COALESCE' }, [value, fallback]);
+  return response;
+}
+
+function fromExcelDateTransform(
+  node: acorn.CallExpression,
+  context: ParseContext,
+  arg: ExpressionValue,
+): ExpressionValue {
+  fromExcelDateTransformValidator(context, arg);
+  const correctedSerial = toBinaryExpression('-', arg, {
+    type: 'number',
+    value: 2,
+  });
+
+  return toFunction({ type: 'default', value: 'DATEADD' }, [
+    { type: 'default', value: 'DAY' },
+    correctedSerial,
+    { type: 'string', value: '1900-01-01' },
+  ]);
+}
+
+function hasTransform(
+  node: acorn.CallExpression,
+  context: ParseContext,
+  args: ExpressionValue[],
+  searchValue: ExpressionValue,
+): ExpressionValue {
+  hasTransformValidator(context, args, searchValue);
+  const conditions = args.map((arg) => toBinaryExpression('=', arg, searchValue));
+  const [first, ...rest] = conditions;
+  const orCondition = rest.reduce((acc, cond) => toBinaryExpression('OR', acc, cond), first);
+
+  const whenClause = toWhen(orCondition, { type: 'number', value: 1 });
+  const elseClause = toElse({ type: 'number', value: 0 });
+
+  return toCase({ whenList: [whenClause], elseResult: elseClause });
+}
+
+function hasSomeTransform(
+  node: acorn.CallExpression,
+  context: ParseContext,
+  args: ExpressionValue[],
+  ...valueArray: ExpressionValue[]
+): ExpressionValue {
+  hasSomeTransformValidator(context, args, valueArray);
+  const comparisons: Binary[] = [];
+  args.forEach((col) => {
+    valueArray.forEach((valGroup) => {
+      if (Array.isArray(valGroup)) {
+        valGroup.forEach((val) => {
+          const comp = toBinaryExpression('=', col, val);
+          comparisons.push(comp);
+        });
+      } else {
+        const comp = toBinaryExpression('=', col, valGroup);
+        comparisons.push(comp);
+      }
+    });
+  });
+
+  const [first, ...rest] = comparisons;
+  const orCondition = rest.reduce((acc, cond) => toBinaryExpression('OR', acc, cond), first);
+  const whenClause = toWhen(orCondition, { type: 'number', value: 1 });
+  const elseClause = toElse({ type: 'number', value: 0 });
+
+  return toCase({ whenList: [whenClause], elseResult: elseClause });
+}
+
+function filterIfTransform(
+  node: acorn.CallExpression,
+  context: ParseContext,
+  columnArg: ExpressionValue,
+  conditionArg: ExpressionValue,
+): ExpressionValue {
+  filterIfTransformValidator(context, columnArg, conditionArg);
+  const currentColumnId = context.currentColumnId;
+  const valueColumnName = `val_${currentColumnId}`;
+  const colName =
+    columnArg.type === 'column_ref'
+      ? (columnArg as ColumnRefItem).column
+      : (columnArg as Value).value;
+  const conditionBuilder = (valueColumnName: string) => {
+    if (conditionArg.type === 'string') {
+      const conditionWithLhs = `${colName} ${conditionArg.value}`;
+      const localContext = new ParseContext({
+        columnConfigMap: {
+          ...context.columnConfigMap,
+          [valueColumnName]: {
+            columnName: valueColumnName,
+            columnType: MDM_COLUMN_TYPE.NUMBER,
+            columnMeta: { tableName: context.tableName },
+          },
+        },
+        currentColumnId: context.currentColumnId,
+        primaryKeyColumns: context.primaryKeyColumns,
+        tableName: context.tableName,
+      });
+      const parser = createJsToSqlParser(localContext);
+      return parser.parse(conditionWithLhs);
+    }
+    throw new Error('Invalid condition type');
+  };
+  const conditionExpr = conditionBuilder(valueColumnName);
+  const whenClause = toWhen(conditionExpr, columnArg);
+  const elseClause = toElse({ type: 'null', value: null });
+
+  return toCase({
+    whenList: [whenClause],
+    elseResult: elseClause,
+  });
+}
+
+function dateTransform(
+  node: acorn.CallExpression,
+  context: ParseContext,
+  date: ExpressionValue,
+  format: ExpressionValue,
+  year: ExpressionValue,
+): ExpressionValue {
+  dateTransformValidator(context, date, format, year);
+  if (!year) {
+    const sqlFnName = 'FORMAT';
+    const name = { type: 'default', value: sqlFnName } as ValueExpr<string>;
+    return toFunction(name, [date, format]);
+  }
+  const sqlFnName = 'DATEFROMPARTS';
+  const name = { type: 'default', value: sqlFnName } as ValueExpr<string>;
+  return toFunction(name, [date, format, year]);
+}
+
+function switchTransform(
+  node: acorn.CallExpression,
+  context: ParseContext,
+  ...args: ExpressionValue[]
+): ExpressionValue {
+  switchTransformValidator(context, args);
+  const switchExpr = args[0];
+  const remainingArgs = args.slice(1);
+  const whenList: {
+    cond: Binary;
+    result: ExpressionValue;
+    type: 'when';
+  }[] = [];
+
+  const hasElse = remainingArgs.length % 2 === 1;
+  const elseValue = hasElse
+    ? remainingArgs[remainingArgs.length - 1]
+    : { type: 'null', value: null };
+
+  // Iterate over condition-result pairs
+  remainingArgs.slice(0, hasElse ? -1 : undefined).forEach((arg, index, array) => {
+    if (index % 2 === 0) {
+      const matchValue = arg;
+      const resultValue = array[index + 1];
+      const condition = toBinaryExpression('=', switchExpr, matchValue);
+      whenList.push({
+        cond: condition,
+        result: resultValue,
+        type: 'when',
+      });
+    }
+  });
+
+  return toCase({
+    whenList,
+    elseResult: toElse(elseValue),
+  });
+}
+
+function hasAllTransform(
+  node: acorn.CallExpression,
+  context: ParseContext,
+  args: ExpressionValue[],
+  ...valueArray: ExpressionValue[][]
+): ExpressionValue {
+  hasAllTransformValidator(context, args, valueArray);
+  const andConditions: Binary[] = [];
+
+  valueArray.forEach((valGroup) => {
+    const innerComparisons: Binary[] = [];
+    if (Array.isArray(valGroup)) {
+      valGroup.forEach((val) => {
+        args.forEach((col) => {
+          innerComparisons.push(toBinaryExpression('=', col, val));
+        });
+      });
+    }
+
+    const [first, ...rest] = innerComparisons;
+    const orCondition = rest.reduce((acc, cond) => toBinaryExpression('OR', acc, cond), first);
+    andConditions.push(orCondition);
+  });
+
+  const [firstAnd, ...restAnd] = andConditions;
+  const finalCondition = restAnd.reduce(
+    (acc, cond) => toBinaryExpression('AND', acc, cond),
+    firstAnd,
+  );
+
+  const whenClause = toWhen(finalCondition, { type: 'number', value: 1 });
+  const elseClause = toElse({ type: 'number', value: 0 });
+
+  return toCase({ whenList: [whenClause], elseResult: elseClause });
+}
+
+/**
+ * Transforms `find` call expression to SQL expression.
+ */
+function findTransform(
+  node: acorn.CallExpression,
+  context: ParseContext,
+  ...args: ExpressionValue[]
+): ExpressionValue {
+  const sqlFnName = 'CHARINDEX';
+  const name = { type: 'default', value: sqlFnName } as ValueExpr<string>;
+  if (args.length < 2) {
+    throw new Error('FIND() requires at least 2 arguments (substring, string)');
+  }
+
+  return toFunction(name, args);
+}