Function compileFunction

packages/electric-db-collection/src/sql-compiler.ts:168–367

(
  exp: IR.Func<unknown>,
  params: Array<unknown> = [],
  encodeColumnName?: ColumnEncoder,
)

}

function compileFunction(
  exp: IR.Func<unknown>,
  params: Array<unknown> = [],
  encodeColumnName?: ColumnEncoder,
): string {
  const { name, args } = exp

  const opName = getOpName(name)

  // Handle comparison operators with null/undefined values
  // These would create invalid queries with missing params (e.g., "col = $1" with empty params)
  // In SQL, all comparisons with NULL return UNKNOWN, so these are almost always mistakes
  if (isComparisonOp(name)) {
    const nullArgIndex = args.findIndex((arg: IR.BasicExpression) =>
      isNullValue(arg),
    )

    if (nullArgIndex !== -1) {
      // All comparison operators (including eq) throw an error for null values
      // Users should use isNull() or isUndefined() to check for null values
      throw new Error(
        `Cannot use null/undefined value with '${name}' operator. ` +
          `Comparisons with null always evaluate to UNKNOWN in SQL. ` +
          `Use isNull() or isUndefined() to check for null values, ` +
          `or filter out null values before building the query.`,
      )
    }
  }

  const compiledArgs = args.map((arg: IR.BasicExpression) =>
    compileBasicExpression(arg, params, encodeColumnName),
  )

  // Special case for IS NULL / IS NOT NULL - these are postfix operators
  if (name === `isNull` || name === `isUndefined`) {
    if (compiledArgs.length !== 1) {
      throw new Error(`${name} expects 1 argument`)
    }
    return `${compiledArgs[0]} ${opName}`
  }

  // Special case for NOT - unary prefix operator
  if (name === `not`) {
    if (compiledArgs.length !== 1) {
      throw new Error(`NOT expects 1 argument`)
    }
    // Check if the argument is IS NULL to generate IS NOT NULL
    const arg = args[0]
    if (arg && arg.type === `func`) {
      const funcArg = arg
      if (funcArg.name === `isNull` || funcArg.name === `isUndefined`) {
        const innerArg = compileBasicExpression(
          funcArg.args[0]!,
          params,
          encodeColumnName,
        )
        return `${innerArg} IS NOT NULL`
      }