Function compileFunction

packages/powersync-db-collection/src/sqlite-compiler.ts:168–341

* Compiles a function expression (operator) to SQL.

(
  exp: IR.Func<unknown>,
  params: Array<unknown>,
  compileOptions?: CompileSQLiteOptions,
)

 * Compiles a function expression (operator) to SQL.
 */
function compileFunction(
  exp: IR.Func<unknown>,
  params: Array<unknown>,
  compileOptions?: CompileSQLiteOptions,
): string {
  const { name, args } = exp

  // Check for null values in comparison operators
  if (isComparisonOp(name)) {
    const hasNullArg = args.some((arg: IR.BasicExpression) => isNullValue(arg))
    if (hasNullArg) {
      throw new Error(
        `Cannot use null/undefined with '${name}' operator. ` +
          `Use isNull() to check for null values.`,
      )
    }
  }

  // Compile arguments
  const compiledArgs = args.map((arg: IR.BasicExpression) =>
    compileExpression(arg, params, compileOptions),
  )

  // Handle different operator types
  switch (name) {
    // Binary comparison operators
    case `eq`:
    case `gt`:
    case `gte`:
    case `lt`:
    case `lte`: {
      if (compiledArgs.length !== 2) {
        throw new Error(`${name} expects 2 arguments`)
      }
      const opSymbol = getComparisonOp(name)
      return `${compiledArgs[0]} ${opSymbol} ${compiledArgs[1]}`
    }

    // Logical operators
    case `and`:
    case `or`: {
      if (compiledArgs.length < 2) {
        throw new Error(`${name} expects at least 2 arguments`)
      }
      const opKeyword = name === `and` ? `AND` : `OR`
      return compiledArgs
        .map((arg: string) => `(${arg})`)
        .join(` ${opKeyword} `)
    }

    case `not`: {
      if (compiledArgs.length !== 1) {
        throw new Error(`not expects 1 argument`)
      }
      // Check if argument is isNull/isUndefined for IS NOT NULL
      const arg = args[0]
      if (arg && arg.type === `func`) {
        if (arg.name === `isNull` || arg.name === `isUndefined`) {