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

package/src/js-lib/db/validator/FormulaValidator.ts

@@ -0,0 +1,1235 @@
+/**
+ * validators.ts
+ *
+ * This file contains reusable validation functions for transform argument checking.
+ * Each validator accepts the parsing context and arguments to validate types, argument count, etc.
+ *
+ * These functions help keep transform functions clean by centralizing validation logic,
+ * providing consistent error handling and context updates.
+ *
+ * Usage:
+ *   import { concatenateTransformValidator, dateArgumentValidator } from './validators';
+ *
+ *   // In your transform function:
+ *   concatenateTransformValidator(context, args);
+ *   dateArgumentValidator(context, dateArg, 'MONTH');
+ */
+
+import { ParseContext } from '../../ParseContext';
+import { ExpressionValue } from '../../../sql-types';
+import { getArgType } from '@/utils';
+
+export function ifTransformValidator(context: ParseContext, args: ExpressionValue[]) {
+  if (args.length < 3) {
+    context.isValid = false;
+    context.error = 'IF() requires 3 arguments';
+    return;
+  }
+  const trueValueType = getArgType(args[1], context);
+  const falseValueType = getArgType(args[2], context);
+  if (trueValueType !== falseValueType) {
+    context.isValid = false;
+    context.error = `Both true value and false value should of same type`;
+    return;
+  }
+  if (falseValueType) context.returnType = falseValueType;
+}
+
+export function todayTransformValidator(context: ParseContext): void {
+  context.returnType = 'date';
+}
+
+export function nowTransformValidator(context: ParseContext): void {
+  context.returnType = 'datetime';
+}
+
+export function concatenateTransformValidator(context: ParseContext, args: ExpressionValue[]) {
+  if (args.length < 2) {
+    context.isValid = false;
+    context.error = 'CONCATENATE() requires at least 2 arguments';
+    return;
+  }
+  context.returnType = 'string';
+}
+
+export function lowerTransformValidator(context: ParseContext, arg: ExpressionValue) {
+  if (!arg) {
+    context.isValid = false;
+    context.error = 'LOWER() requires 1 argument';
+    return;
+  }
+  if (getArgType(arg, context) !== 'string') {
+    context.isValid = false;
+    context.error = 'Argument to LOWER must be of type string';
+    return;
+  }
+  context.returnType = 'string';
+}
+
+export function dateArgumentValidator(context: ParseContext, arg: ExpressionValue, fnName: string) {
+  if (!arg) {
+    context.isValid = false;
+    context.error = `${fnName}() requires 1 argument`;
+    return;
+  }
+  if (getArgType(arg, context) !== 'date') {
+    context.isValid = false;
+    context.error = `Argument to ${fnName} must be of type date in format 'YYYY-MM-DD'`;
+    return;
+  }
+  context.returnType = 'number';
+}
+
+export function trimTransformValidator(context: ParseContext, arg: ExpressionValue) {
+  if (!arg) {
+    context.isValid = false;
+    context.error = 'TRIM() requires 1 argument';
+    return;
+  }
+  if (getArgType(arg, context) !== 'string') {
+    context.isValid = false;
+    context.error = 'Argument to TRIM must be of type string';
+    return;
+  }
+  context.returnType = 'string';
+}
+
+export function upperTransformValidator(context: ParseContext, arg: ExpressionValue) {
+  if (!arg) {
+    context.isValid = false;
+    context.error = 'UPPER() requires 1 argument';
+    return;
+  }
+  if (getArgType(arg, context) !== 'string') {
+    context.isValid = false;
+    context.error = 'Argument to UPPER must be of type string';
+    return;
+  }
+  context.returnType = 'string';
+}
+
+export function lenTransformValidator(context: ParseContext, arg: ExpressionValue) {
+  if (!arg) {
+    context.isValid = false;
+    context.error = 'LEN() requires exactly 1 argument';
+    return;
+  }
+  if (getArgType(arg, context) !== 'string') {
+    context.isValid = false;
+    context.error = 'Argument to LEN must be of type string';
+    return;
+  }
+  context.returnType = 'number';
+}
+
+export function leftTransformValidator(context: ParseContext, args: ExpressionValue[]) {
+  if (args.length !== 2) {
+    context.isValid = false;
+    context.error = 'LEFT() requires exactly 2 arguments';
+    return;
+  }
+  if (getArgType(args[0], context) !== 'string') {
+    context.isValid = false;
+    context.error = 'First argument to LEFT must be of type string';
+    return;
+  }
+  if (getArgType(args[1], context) !== 'number') {
+    context.isValid = false;
+    context.error = 'Second argument to LEFT must be of type number';
+    return;
+  }
+  context.returnType = 'string';
+}
+
+export function rightTransformValidator(context: ParseContext, args: ExpressionValue[]) {
+  if (args.length !== 2) {
+    context.isValid = false;
+    context.error = 'RIGHT() requires exactly 2 arguments';
+    return;
+  }
+  if (getArgType(args[0], context) !== 'string') {
+    context.isValid = false;
+    context.error = 'First argument to RIGHT must be of type string';
+    return;
+  }
+  if (getArgType(args[1], context) !== 'number') {
+    context.isValid = false;
+    context.error = 'Second argument to RIGHT must be of type number';
+    return;
+  }
+  context.returnType = 'string';
+}
+
+export function replaceTransformValidator(context: ParseContext, args: ExpressionValue[]) {
+  const types = ['string', 'number', 'number', 'string'];
+  if (args.length !== types.length) {
+    context.isValid = false;
+    context.error = 'REPLACE() requires 4 arguments';
+    return;
+  }
+  args.forEach((arg, i) => {
+    if (getArgType(arg, context) !== types[i]) {
+      context.isValid = false;
+      context.error = `Argument ${i + 1} to REPLACE must be of type ${types[i]}`;
+      return;
+    }
+  });
+  context.returnType = 'string';
+}
+
+export function reptTransformValidator(context: ParseContext, args: ExpressionValue[]) {
+  const types = ['string', 'number'];
+  if (args.length !== types.length) {
+    context.isValid = false;
+    context.error = 'REPT() requires 2 arguments';
+    return;
+  }
+  args.forEach((arg, i) => {
+    if (getArgType(arg, context) !== types[i]) {
+      context.isValid = false;
+      context.error = `Argument ${i + 1} to REPT must be of type ${types[i]}`;
+      return;
+    }
+  });
+  context.returnType = 'string';
+}
+
+export function matchTransformValidator(context: ParseContext, args: ExpressionValue[]) {
+  const types = ['string', 'string'];
+  if (args.length !== types.length) {
+    context.isValid = false;
+    context.error = 'MATCH() requires 2 arguments';
+    return;
+  }
+  args.forEach((arg, i) => {
+    if (getArgType(arg, context) !== types[i]) {
+      context.isValid = false;
+      context.error = `Argument ${i + 1} to MATCH must be of type ${types[i]}`;
+      return;
+    }
+  });
+  context.returnType = 'boolean';
+}
+
+export function dateAddTransformValidator(context: ParseContext, args: ExpressionValue[]) {
+  if (args.length !== 2) {
+    context.isValid = false;
+    context.error = 'DATEADD() requires 2 arguments';
+    return;
+  }
+  if (getArgType(args[0], context) !== 'date') {
+    context.isValid = false;
+    context.error = "First argument to DATEADD must be of type date in format 'YYYY-MM-DD'";
+    return;
+  }
+  if (getArgType(args[1], context) !== 'number') {
+    context.isValid = false;
+    context.error = 'Second argument to DATEADD must be of type number';
+    return;
+  }
+  context.returnType = 'date';
+}
+
+export function dateDiffTransformValidator(context: ParseContext, args: ExpressionValue[]) {
+  if (args.length !== 2) {
+    context.isValid = false;
+    context.error = 'DATEDIFF() requires 2 arguments';
+    return;
+  }
+  const types = ['date', 'date'];
+  args.forEach((arg, i) => {
+    if (getArgType(arg, context) !== types[i]) {
+      context.isValid = false;
+      context.error = `Argument ${i + 1} to DATEDIFF must be of type ${types[i]} in format 'YYYY-MM-DD'`;
+      return;
+    }
+  });
+  context.returnType = 'number';
+}
+
+export function dayTransformValidator(context: ParseContext, arg: ExpressionValue) {
+  if (!arg) {
+    context.isValid = false;
+    context.error = 'DAY() requires 1 argument';
+    return;
+  }
+  if (getArgType(arg, context) !== 'date') {
+    context.isValid = false;
+    context.error = "Argument to DAY must be of type date in format 'YYYY-MM-DD'";
+    return;
+  }
+  context.returnType = 'number';
+}
+
+export function monthTransformValidator(context: ParseContext, arg: ExpressionValue) {
+  if (!arg) {
+    context.isValid = false;
+    context.error = 'MONTH() requires 1 argument';
+    return;
+  }
+  if (getArgType(arg, context) !== 'date') {
+    context.isValid = false;
+    context.error = "Argument to MONTH must be of type date in format 'YYYY-MM-DD'";
+    return;
+  }
+  context.returnType = 'number';
+}
+
+export function yearTransformValidator(context: ParseContext, arg: ExpressionValue) {
+  if (!arg) {
+    context.isValid = false;
+    context.error = 'YEAR() requires 1 argument';
+    return;
+  }
+  if (getArgType(arg, context) !== 'date') {
+    context.isValid = false;
+    context.error = "Argument to YEAR must be of type date in format 'YYYY-MM-DD'";
+    return;
+  }
+  context.returnType = 'number';
+}
+
+export function eomonthTransformValidator(context: ParseContext, args: ExpressionValue[]) {
+  if (args.length < 1 || args.length > 2) {
+    context.isValid = false;
+    context.error = 'EOMONTH() requires 1 or 2 arguments';
+    return;
+  }
+
+  if (getArgType(args[0], context) !== 'date') {
+    context.isValid = false;
+    context.error = "First argument to EOMONTH must be of type date in format 'YYYY-MM-DD'";
+    return;
+  }
+
+  if (args.length === 2 && getArgType(args[1], context) !== 'number') {
+    context.isValid = false;
+    context.error = 'Second argument to EOMONTH must be of type number';
+    return;
+  }
+
+  context.returnType = 'date';
+}
+
+export function divideTransformValidator(context: ParseContext, args: ExpressionValue[]) {
+  if (args.length !== 2) {
+    context.isValid = false;
+    context.error = 'DIVIDE() requires 2 arguments';
+    return;
+  }
+
+  const types = ['number', 'number'];
+  args.forEach((arg, i) => {
+    if (getArgType(arg, context) !== types[i]) {
+      context.isValid = false;
+      context.error = `Argument ${i + 1} to DIVIDE must be of type ${types[i]}`;
+      return;
+    }
+  });
+
+  context.returnType = 'number';
+}
+
+export function andTransformValidator(context: ParseContext, args: ExpressionValue[]) {
+  if (args.length < 2) {
+    context.isValid = false;
+    context.error = 'AND() requires at least 2 arguments';
+    return;
+  }
+
+  args.forEach((arg, i) => {
+    if (getArgType(arg, context) !== 'boolean') {
+      context.isValid = false;
+      context.error = `Argument ${i + 1} to AND must be of type boolean`;
+      return;
+    }
+  });
+
+  context.returnType = 'boolean';
+}
+
+export function orTransformValidator(context: ParseContext, args: ExpressionValue[]) {
+  if (args.length < 2) {
+    context.isValid = false;
+    context.error = 'OR() requires at least 2 arguments';
+    return;
+  }
+
+  args.forEach((arg, i) => {
+    if (getArgType(arg, context) !== 'boolean') {
+      context.isValid = false;
+      context.error = `Argument ${i + 1} to OR must be of type boolean`;
+      return;
+    }
+  });
+
+  context.returnType = 'boolean';
+}
+
+export function ceilTransformValidator(context: ParseContext, arg: ExpressionValue) {
+  if (!arg) {
+    context.isValid = false;
+    context.error = 'CEIL() requires 1 argument';
+    return;
+  }
+
+  if (getArgType(arg, context) !== 'number') {
+    context.isValid = false;
+    context.error = 'Argument to CEIL must be of type number';
+    return;
+  }
+
+  context.returnType = 'number';
+}
+
+export function floorTransformValidator(context: ParseContext, arg: ExpressionValue) {
+  if (!arg) {
+    context.isValid = false;
+    context.error = 'FLOOR() requires 1 argument';
+    return;
+  }
+
+  if (getArgType(arg, context) !== 'number') {
+    context.isValid = false;
+    context.error = 'Argument to FLOOR must be of type number';
+    return;
+  }
+
+  context.returnType = 'number';
+}
+
+export function absTransformValidator(context: ParseContext, arg: ExpressionValue) {
+  if (!arg) {
+    context.isValid = false;
+    context.error = 'ABS() requires 1 argument';
+    return;
+  }
+
+  if (getArgType(arg, context) !== 'number') {
+    context.isValid = false;
+    context.error = 'Argument to ABS must be of type number';
+    return;
+  }
+
+  context.returnType = 'number';
+}
+
+export function roundTransformValidator(context: ParseContext, args: ExpressionValue[]) {
+  if (args.length < 1 || args.length > 2) {
+    context.isValid = false;
+    context.error = 'ROUND() requires 1 or 2 arguments';
+    return;
+  }
+
+  const valueType = getArgType(args[0], context);
+  if (valueType !== 'number') {
+    context.isValid = false;
+    context.error = 'First argument to ROUND must be of type number';
+    return;
+  }
+
+  if (args[1]) {
+    const decimalType = getArgType(args[1], context);
+    if (decimalType !== 'number') {
+      context.isValid = false;
+      context.error = 'Second argument to ROUND must be of type number';
+      return;
+    }
+  }
+
+  context.returnType = 'number';
+}
+
+export function expTransformValidator(context: ParseContext, arg: ExpressionValue) {
+  if (!arg) {
+    context.isValid = false;
+    context.error = 'EXP() requires exactly 1 argument';
+    return;
+  }
+  const type = getArgType(arg, context);
+  if (type !== 'number') {
+    context.isValid = false;
+    context.error = 'Argument to EXP must be of type number';
+    return;
+  }
+  context.returnType = 'number';
+}
+
+export function powTransformValidator(context: ParseContext, args: ExpressionValue[]) {
+  if (args.length !== 2) {
+    context.isValid = false;
+    context.error = 'POW() requires exactly 2 arguments';
+    return;
+  }
+  const types = ['number', 'number'];
+  args.forEach((arg, i) => {
+    if (getArgType(arg, context) !== types[i]) {
+      context.isValid = false;
+      context.error = `Argument ${i + 1} to POW must be of type ${types[i]}`;
+      return;
+    }
+  });
+  context.returnType = 'number';
+}
+
+export function logTransformValidator(context: ParseContext, args: ExpressionValue[]) {
+  if (args.length < 1 || args.length > 2) {
+    context.isValid = false;
+    context.error = 'LOG() requires 1 or 2 arguments';
+    return;
+  }
+  args.forEach((arg, i) => {
+    if (getArgType(arg, context) !== 'number') {
+      context.isValid = false;
+      context.error = `Argument ${i + 1} to LOG must be of type number`;
+      return;
+    }
+  });
+  context.returnType = 'number';
+}
+
+export function sqrtTransformValidator(context: ParseContext, arg: ExpressionValue) {
+  if (!arg) {
+    context.isValid = false;
+    context.error = 'SQRT() requires exactly 1 arguments';
+    return;
+  }
+  if (getArgType(arg, context) !== 'number') {
+    context.isValid = false;
+    context.error = 'Argument to SQRT must be of type number';
+    return;
+  }
+  context.returnType = 'number';
+}
+
+export function modTransformValidator(context: ParseContext, args: ExpressionValue[]) {
+  if (args.length !== 2) {
+    context.isValid = false;
+    context.error = 'MOD() requires exactly 2 arguments';
+    return;
+  }
+  const types = ['number', 'number'];
+  args.forEach((arg, i) => {
+    if (getArgType(arg, context) !== types[i]) {
+      context.isValid = false;
+      context.error = `Argument ${i + 1} to MOD must be of type ${types[i]}`;
+      return;
+    }
+  });
+  context.returnType = 'number';
+}
+
+export function notTransformValidator(context: ParseContext, arg: ExpressionValue) {
+  if (!arg) {
+    context.isValid = false;
+    context.error = 'NOT() requires exactly 1 argument';
+    return;
+  }
+  if (getArgType(arg, context) !== 'boolean') {
+    context.isValid = false;
+    context.error = 'Argument to NOT must be of type boolean';
+    return;
+  }
+  context.returnType = 'boolean';
+}
+
+export function randTransformValidator(context: ParseContext) {
+  context.returnType = 'number';
+}
+
+export function randBetweenTransformValidator(context: ParseContext, args: ExpressionValue[]) {
+  if (args.length !== 2) {
+    context.isValid = false;
+    context.error = 'RAND_BETWEEN() requires exactly 2 arguments';
+    return;
+  }
+  const types = ['number', 'number'];
+  args.forEach((arg, i) => {
+    if (getArgType(arg, context) !== types[i]) {
+      context.isValid = false;
+      context.error = `Argument ${i + 1} to RAND_BETWEEN must be of type ${types[i]}`;
+      return;
+    }
+  });
+  context.returnType = 'number';
+}
+
+export function averageTransformValidator(context: ParseContext, args: ExpressionValue[]) {
+  if (args.length < 1) {
+    context.isValid = false;
+    context.error = 'AVERAGE() requires at least 1 argument';
+    return;
+  }
+  for (let i = 0; i < args.length; i++) {
+    if (getArgType(args[i], context) !== 'number') {
+      context.isValid = false;
+      context.error = `Argument ${i + 1} to AVERAGE must be of type number`;
+      return;
+    }
+  }
+  context.returnType = 'number';
+}
+
+export function averageIfTransformValidator(
+  context: ParseContext,
+  valueList: ExpressionValue[],
+  condition: ExpressionValue,
+) {
+  if (valueList.length < 1) {
+    context.isValid = false;
+    context.error = 'AVERAGE_IF() requires at least one value to average';
+    return;
+  }
+
+  for (let i = 0; i < valueList.length; i++) {
+    if (getArgType(valueList[i], context) !== 'number') {
+      context.isValid = false;
+      context.error = `Argument ${i + 1} in value list must be of type number`;
+      return;
+    }
+  }
+
+  if (condition.type !== 'string') {
+    context.isValid = false;
+    context.error =
+      'The first argument in AVERAGE_IF must be a string representing a condition expression';
+    return;
+  }
+
+  context.returnType = 'number';
+}
+
+export function averageXNegTransformValidator(context: ParseContext, valueList: ExpressionValue[]) {
+  if (valueList.length < 1) {
+    context.isValid = false;
+    context.error = 'AVERAGE_X_NEG() requires at least one numeric argument';
+    return;
+  }
+  for (let i = 0; i < valueList.length; i++) {
+    if (getArgType(valueList[i], context) !== 'number') {
+      context.isValid = false;
+      context.error = `Argument ${i + 1} to AVERAGE_X_NEG must be of type number`;
+      return;
+    }
+  }
+  context.returnType = 'number';
+}
+
+export function averageXZeroTransformValidator(
+  context: ParseContext,
+  valueList: ExpressionValue[],
+) {
+  if (valueList.length < 1) {
+    context.isValid = false;
+    context.error = 'AVERAGE_X_ZERO() requires at least one numeric argument';
+    return;
+  }
+  for (let i = 0; i < valueList.length; i++) {
+    if (getArgType(valueList[i], context) !== 'number') {
+      context.isValid = false;
+      context.error = `Argument ${i + 1} to AVERAGE_X_ZERO must be of type number`;
+      return;
+    }
+  }
+  context.returnType = 'number';
+}
+
+export function averageXZeroNegTransformValidator(
+  context: ParseContext,
+  valueList: ExpressionValue[],
+) {
+  if (valueList.length < 1) {
+    context.isValid = false;
+    context.error = 'AVERAGE_X_ZERO_NEG() requires at least one numeric argument';
+    return;
+  }
+  for (let i = 0; i < valueList.length; i++) {
+    if (getArgType(valueList[i], context) !== 'number') {
+      context.isValid = false;
+      context.error = `Argument ${i + 1} to AVERAGE_X_ZERO_NEG must be of type number`;
+      return;
+    }
+  }
+  context.returnType = 'number';
+}
+
+export function numberValueTransformValidator(context: ParseContext, args: ExpressionValue[]) {
+  if (args.length < 1 || args.length > 3) {
+    context.isValid = false;
+    context.error = 'NUMBERVALUE() requires 1, 2, or 3 arguments';
+    return;
+  }
+  if (getArgType(args[0], context) !== 'string' && getArgType(args[0], context) !== 'number') {
+    context.isValid = false;
+    context.error = 'First argument to NUMBERVALUE must be string or number';
+    return;
+  }
+  if (args[1] && getArgType(args[1], context) !== 'string') {
+    context.isValid = false;
+    context.error = 'Second argument to NUMBERVALUE must be string';
+    return;
+  }
+  if (args[2] && getArgType(args[2], context) !== 'string') {
+    context.isValid = false;
+    context.error = 'Third argument to NUMBERVALUE must be string';
+    return;
+  }
+  context.returnType = 'number';
+}
+
+export function oddTransformValidator(context: ParseContext, arg: ExpressionValue) {
+  if (!arg) {
+    context.isValid = false;
+    context.error = 'ODD() requires 1 argument';
+    return;
+  }
+  if (getArgType(arg, context) !== 'number') {
+    context.isValid = false;
+    context.error = 'Argument to ODD must be of type number';
+    return;
+  }
+  context.returnType = 'number';
+}
+
+export function evenTransformValidator(context: ParseContext, arg: ExpressionValue) {
+  if (!arg) {
+    context.isValid = false;
+    context.error = 'EVEN() requires 1 argument';
+    return;
+  }
+  if (getArgType(arg, context) !== 'number') {
+    context.isValid = false;
+    context.error = 'Argument to EVEN must be of type number';
+    return;
+  }
+  context.returnType = 'number';
+}
+
+export function inTransformValidator(context: ParseContext, args: ExpressionValue[]) {
+  if (args.length !== 2) {
+    context.isValid = false;
+    context.error = 'IN() requires exactly 2 arguments: column and an array of values';
+    return;
+  }
+  const [column, values] = args;
+  const columnType = getArgType(column, context);
+  if (columnType === null || !['string', 'number'].includes(columnType)) {
+    context.isValid = false;
+    context.error =
+      'First argument to IN must be a string or number or column reference of type string or number';
+    return;
+  }
+  if (values.type !== 'expr_list' || !Array.isArray(values.value)) {
+    context.isValid = false;
+    context.error = 'Second argument to IN must be an array of values';
+    return;
+  }
+  context.returnType = 'boolean';
+}
+
+export function sumTransformValidator(context: ParseContext, args: ExpressionValue[]) {
+  if (args.length < 1) {
+    context.isValid = false;
+    context.error = 'SUM() requires 1 or more arguments';
+    return;
+  }
+  for (let i = 0; i < args.length; i++) {
+    const argType = getArgType(args[i], context);
+    if (argType !== 'number') {
+      context.isValid = false;
+      context.error = `Argument ${i + 1} to SUM must be of type number`;
+      return;
+    }
+  }
+  context.returnType = 'number';
+}
+
+export function indexOfTransformValidator(
+  context: ParseContext,
+  valueList: ExpressionValue[],
+  valueToFind: ExpressionValue,
+) {
+  if (!valueList || !valueToFind) {
+    context.isValid = false;
+    context.error = 'INDEXOF() requires 2 arguments';
+    return;
+  }
+  if (!Array.isArray(valueList) || valueList.length === 0) {
+    context.isValid = false;
+    context.error = 'First argument to INDEXOF must be a non-empty array';
+    return;
+  }
+  for (let i = 0; i < valueList.length; i++) {
+    const t = getArgType(valueList[i], context);
+    if (t !== 'string' && t !== 'number') {
+      context.isValid = false;
+      context.error = `Argument ${i + 1} in valueList must be string or number`;
+      return;
+    }
+  }
+  const searchType = getArgType(valueToFind, context);
+  if (searchType !== 'string' && searchType !== 'number') {
+    context.isValid = false;
+    context.error = 'Second argument to INDEXOF must be string or number';
+    return;
+  }
+  context.returnType = 'number';
+}
+
+export function isEmptyTransformValidator(context: ParseContext, arg: ExpressionValue) {
+  if (!arg) {
+    context.isValid = false;
+    context.error = 'ISEMPTY() requires exactly 1 argument';
+    return;
+  }
+  const type = getArgType(arg, context);
+  if (!['string', 'null'].includes(type || '')) {
+    context.isValid = false;
+    context.error = 'Argument to ISEMPTY must be of type string or null';
+    return;
+  }
+  context.returnType = 'boolean';
+}
+
+export function isNumberTransformValidator(context: ParseContext, arg: ExpressionValue) {
+  if (!arg) {
+    context.isValid = false;
+    context.error = 'ISNUMBER() requires exactly 1 argument';
+    return;
+  }
+  const type = getArgType(arg, context);
+  if (type !== 'string' && type !== 'number') {
+    context.isValid = false;
+    context.error = 'Argument to ISNUMBER must be of type string or number';
+    return;
+  }
+  context.returnType = 'boolean';
+}
+
+export function maxAggregateTransformValidator(context: ParseContext, args: ExpressionValue[]) {
+  if (args.length < 1) {
+    context.isValid = false;
+    context.error = 'GREATEST() requires 1 or more arguments';
+    return;
+  }
+  for (let i = 0; i < args.length; i++) {
+    const type = getArgType(args[i], context);
+    if (type !== 'number') {
+      context.isValid = false;
+      context.error = `Argument ${i + 1} to GREATEST must be of type number`;
+      return;
+    }
+  }
+  context.returnType = 'number';
+}
+
+export function minAggregateTransformValidator(context: ParseContext, args: ExpressionValue[]) {
+  if (args.length < 1) {
+    context.isValid = false;
+    context.error = 'LEAST() requires 1 or more arguments';
+    return;
+  }
+  for (let i = 0; i < args.length; i++) {
+    const type = getArgType(args[i], context);
+    if (type !== 'number') {
+      context.isValid = false;
+      context.error = `Argument ${i + 1} to LEAST must be of type number`;
+      return;
+    }
+  }
+  context.returnType = 'number';
+}
+
+export function midTransformValidator(context: ParseContext, args: ExpressionValue[]) {
+  if (args.length !== 3) {
+    context.isValid = false;
+    context.error = 'MID() requires exactly 3 arguments';
+    return;
+  }
+  const [strArg, startArg, lengthArg] = args;
+  if (getArgType(strArg, context) !== 'string') {
+    context.isValid = false;
+    context.error = 'First argument to MID must be of type string';
+    return;
+  }
+  if (getArgType(startArg, context) !== 'number') {
+    context.isValid = false;
+    context.error = 'Second argument to MID must be of type number';
+    return;
+  }
+  if (getArgType(lengthArg, context) !== 'number') {
+    context.isValid = false;
+    context.error = 'Third argument to MID must be of type number';
+    return;
+  }
+  context.returnType = 'string';
+}
+
+export function medianTransformValidator(context: ParseContext, args: ExpressionValue[]) {
+  if (args.length < 1) {
+    context.isValid = false;
+    context.error = 'MEDIAN() requires 1 or more arguments';
+    return;
+  }
+  for (let i = 0; i < args.length; i++) {
+    const type = getArgType(args[i], context);
+    if (type !== 'number') {
+      context.isValid = false;
+      context.error = `Argument ${i + 1} to MEDIAN must be of type number`;
+      return;
+    }
+  }
+  context.returnType = 'number';
+}
+
+export function modeTransformValidator(context: ParseContext, args: ExpressionValue[]) {
+  if (args.length < 1) {
+    context.isValid = false;
+    context.error = 'MODE() requires 1 or more arguments';
+    return;
+  }
+  for (let i = 0; i < args.length; i++) {
+    const type = getArgType(args[i], context);
+    if (type !== 'number') {
+      context.isValid = false;
+      context.error = `Argument ${i + 1} to MODE must be of type number`;
+      return;
+    }
+  }
+  context.returnType = 'number';
+}
+
+export function valueTransformValidator(context: ParseContext, arg: ExpressionValue) {
+  if (!arg) {
+    context.isValid = false;
+    context.error = 'VALUE() requires exactly 1 argument';
+    return;
+  }
+
+  const type = getArgType(arg, context);
+  if (!['string', 'number'].includes(type || '')) {
+    context.isValid = false;
+    context.error = 'VALUE() accepts only string or number as input';
+    return;
+  }
+
+  context.returnType = 'number';
+}
+
+export function pctTransformValidator(context: ParseContext, arg: ExpressionValue) {
+  if (!arg) {
+    context.isValid = false;
+    context.error = 'PCT() requires exactly 1 argument';
+    return;
+  }
+
+  const type = getArgType(arg, context);
+  if (type !== 'number') {
+    context.isValid = false;
+    context.error = 'PCT() argument must be of type number';
+    return;
+  }
+
+  context.returnType = 'number';
+}
+
+export function xorTransformValidator(context: ParseContext, args: ExpressionValue[]) {
+  if (args.length !== 2) {
+    context.isValid = false;
+    context.error = 'XOR() requires exactly 2 arguments';
+    return;
+  }
+
+  const [arg1Type, arg2Type] = args.map((arg) => getArgType(arg, context));
+  if (arg1Type !== 'boolean' || arg2Type !== 'boolean') {
+    context.isValid = false;
+    context.error = 'XOR() arguments must both be of type boolean';
+    return;
+  }
+
+  context.returnType = 'boolean';
+}
+
+export function textTransformValidator(context: ParseContext, args: ExpressionValue[]) {
+  if (args.length < 2 || args.length > 3) {
+    context.isValid = false;
+    context.error = 'TEXT() requires 2 or 3 arguments';
+    return;
+  }
+
+  const [valueType, formatType, localeType] = args.map((arg) => getArgType(arg, context));
+  if (!['number', 'date'].includes(valueType || '')) {
+    context.isValid = false;
+    context.error = 'First argument to TEXT() must be of type number or date';
+    return;
+  }
+  if (formatType !== 'string') {
+    context.isValid = false;
+    context.error = 'Second argument to TEXT() must be a string format pattern';
+    return;
+  }
+  if (args[2] && localeType !== 'string') {
+    context.isValid = false;
+    context.error = 'Third argument to TEXT() (locale) must be a string';
+    return;
+  }
+
+  context.returnType = 'string';
+}
+
+export function uuidTransformValidator(context: ParseContext) {
+  context.returnType = 'string';
+}
+
+export function ifNullTransformValidator(context: ParseContext, args: ExpressionValue[]) {
+  if (args.length !== 2) {
+    context.isValid = false;
+    context.error = 'IFNA() requires exactly 2 arguments';
+    return;
+  }
+
+  const [valueType, fallbackType] = args.map((arg) => getArgType(arg, context));
+  if (valueType !== fallbackType && valueType !== null && fallbackType !== null) {
+    context.isValid = false;
+    context.error = 'Both arguments to IFNA() must be of the same type';
+    return;
+  }
+
+  context.returnType = valueType || fallbackType || 'string';
+}
+
+export function fromExcelDateTransformValidator(context: ParseContext, arg: ExpressionValue) {
+  if (!arg) {
+    context.isValid = false;
+    context.error = 'FROMEXCELDATE() requires exactly 1 argument';
+    return;
+  }
+  const argType = getArgType(arg, context);
+  if (argType !== 'number') {
+    context.isValid = false;
+    context.error = 'FROMEXCELDATE() argument must be a number';
+    return;
+  }
+  context.returnType = 'date';
+}
+
+export function hasTransformValidator(
+  context: ParseContext,
+  args: ExpressionValue[],
+  searchValue: ExpressionValue,
+) {
+  if (args.length === 0) {
+    context.isValid = false;
+    context.error = 'HAS() requires at least one column to check against';
+    return;
+  }
+
+  const searchType = getArgType(searchValue, context);
+  for (let i = 0; i < args.length; i++) {
+    const argType = getArgType(args[i], context);
+    if (argType !== searchType) {
+      context.isValid = false;
+      context.error = `Argument ${i + 1} to HAS must be of the same type as searchValue (${searchType})`;
+      return;
+    }
+  }
+  context.returnType = 'number';
+}
+
+export function hasSomeTransformValidator(
+  context: ParseContext,
+  args: ExpressionValue[],
+  valueArray: ExpressionValue[],
+) {
+  if (args.length === 0) {
+    context.isValid = false;
+    context.error = 'HAS_SOME() requires at least one column to check against';
+    return;
+  }
+  if (valueArray.length === 0) {
+    context.isValid = false;
+    context.error = 'HAS_SOME() requires at least one search value';
+    return;
+  }
+  const flattenedValues: ExpressionValue[] = [];
+  valueArray.forEach((valGroup) => {
+    if (Array.isArray(valGroup)) {
+      valGroup.forEach((val) => flattenedValues.push(val));
+    } else {
+      flattenedValues.push(valGroup);
+    }
+  });
+  for (let i = 0; i < args.length; i++) {
+    const colType = getArgType(args[i], context);
+    for (let j = 0; j < flattenedValues.length; j++) {
+      const valType = getArgType(flattenedValues[j], context);
+      if (colType !== valType) {
+        context.isValid = false;
+        context.error = `Argument ${i + 1} and value ${j + 1} to HAS_SOME must be of the same type (${colType} vs ${valType})`;
+        return;
+      }
+    }
+  }
+
+  context.returnType = 'number';
+}
+
+export function filterIfTransformValidator(
+  context: ParseContext,
+  columnArg: ExpressionValue,
+  conditionArg: ExpressionValue,
+) {
+  const colType = getArgType(columnArg, context);
+  if (colType !== 'string' && colType !== 'number') {
+    context.isValid = false;
+    context.error = 'First argument to FILTER_IF must be a column reference or a valid column';
+    return;
+  }
+  if (getArgType(conditionArg, context) !== 'string') {
+    context.isValid = false;
+    context.error = 'Second argument to FILTER_IF must be of type string';
+    return;
+  }
+  context.returnType = colType;
+}
+
+export function dateTransformValidator(
+  context: ParseContext,
+  date: ExpressionValue,
+  format: ExpressionValue,
+  year?: ExpressionValue,
+) {
+  const dateType = getArgType(date, context);
+  if (dateType !== 'date' && dateType !== 'string') {
+    context.isValid = false;
+    context.error = 'First argument to DATE must be of type date or string';
+    return;
+  }
+
+  const formatType = getArgType(format, context);
+  if (formatType !== 'string') {
+    context.isValid = false;
+    context.error = 'Second argument (format) to DATE must be of type string';
+    return;
+  }
+
+  if (year !== undefined) {
+    const yearType = getArgType(year, context);
+    if (yearType !== 'number') {
+      context.isValid = false;
+      context.error = 'Third argument (year) to DATE must be of type number';
+      return;
+    }
+  }
+
+  context.returnType = 'date';
+}
+
+export function switchTransformValidator(context: ParseContext, args: ExpressionValue[]) {
+  if (args.length < 3) {
+    context.isValid = false;
+    context.error = 'SWITCH() requires at least 3 arguments';
+    return;
+  }
+
+  const switchExprType = getArgType(args[0], context);
+  if (switchExprType === null) {
+    context.isValid = false;
+    context.error = 'Switch expression has invalid type';
+    return;
+  }
+
+  const remainingArgs = args.slice(1);
+
+  if (remainingArgs.length % 2 !== 0 && remainingArgs.length < 3) {
+    context.isValid = false;
+    context.error = 'SWITCH() requires at least one condition-result pair';
+    return;
+  }
+
+  for (let i = 0; i < remainingArgs.length - (remainingArgs.length % 2); i += 2) {
+    const condType = getArgType(remainingArgs[i], context);
+    if (condType === null || condType !== switchExprType) {
+      context.isValid = false;
+      context.error = `Condition argument ${i + 2} must be of the same type as switch expression (${switchExprType})`;
+      return;
+    }
+  }
+
+  const resultTypes: string[] = [];
+
+  for (let i = 1; i < remainingArgs.length - (remainingArgs.length % 2); i += 2) {
+    const resultType = getArgType(remainingArgs[i], context);
+    if (resultType === null) {
+      context.isValid = false;
+      context.error = `Result argument ${i + 2} has invalid type`;
+      return;
+    }
+    resultTypes.push(resultType);
+  }
+
+  if (remainingArgs.length % 2 === 1) {
+    const elseType = getArgType(remainingArgs[remainingArgs.length - 1], context);
+    if (elseType === null) {
+      context.isValid = false;
+      context.error = 'Else argument has invalid type';
+      return;
+    }
+    resultTypes.push(elseType);
+  }
+
+  const uniqueResultTypes = new Set(resultTypes);
+  if (uniqueResultTypes.size > 1) {
+    context.isValid = false;
+    context.error = 'All result arguments to SWITCH() must be of the same type';
+    return;
+  }
+
+  context.returnType = resultTypes[0];
+}
+
+export function hasAllTransformValidator(
+  context: ParseContext,
+  args: ExpressionValue[],
+  valueArray: ExpressionValue[][],
+) {
+  if (args.length === 0) {
+    context.isValid = false;
+    context.error = 'HAS_ALL() requires at least one column to check against';
+    return;
+  }
+
+  if (valueArray.length === 0) {
+    context.isValid = false;
+    context.error = 'HAS_ALL() requires at least one search value array';
+    return;
+  }
+
+  for (const col of args) {
+    const colType = getArgType(col, context);
+    if (colType === null) {
+      context.isValid = false;
+      context.error = 'One or more columns have invalid type';
+      return;
+    }
+  }
+
+  for (const valGroup of valueArray) {
+    if (!Array.isArray(valGroup) || valGroup.length === 0) {
+      context.isValid = false;
+      context.error = 'Each search value group must be a non-empty array';
+      return;
+    }
+
+    for (const val of valGroup) {
+      const valType = getArgType(val, context);
+      if (valType === null) {
+        context.isValid = false;
+        context.error = 'One or more search values have invalid type';
+        return;
+      }
+    }
+  }
+
+  context.returnType = 'number';
+}