metal-orm 1.0.55 → 1.0.57

package/src/core/functions/datetime.ts

@@ -18,6 +18,7 @@ const toOperand = (input: OperandInput): OperandNode => {
 const fn = (key: string, args: OperandInput[]): FunctionNode => ({
     type: 'Function',
     name: key,
+    fn: key,
     args: args.map(toOperand)
 });
 
@@ -49,6 +50,18 @@ export const currentTime = (): FunctionNode => fn('CURRENT_TIME', []);
  */
 export const utcNow = (): FunctionNode => fn('UTC_NOW', []);
 
+/**
+ * Returns the current local time.
+ * @returns A FunctionNode representing the LOCALTIME SQL function.
+ */
+export const localTime = (): FunctionNode => fn('LOCALTIME', []);
+
+/**
+ * Returns the current local timestamp.
+ * @returns A FunctionNode representing the LOCALTIMESTAMP SQL function.
+ */
+export const localTimestamp = (): FunctionNode => fn('LOCALTIMESTAMP', []);
+
 /**
  * Extracts a specified part from a date or datetime value.
  * @param part - The date part to extract (e.g., 'YEAR', 'MONTH', 'DAY', 'HOUR', 'MINUTE', 'SECOND').
@@ -156,3 +169,40 @@ export const weekOfYear = (date: OperandInput): FunctionNode => fn('WEEK_OF_YEAR
  */
 export const dateTrunc = (part: OperandInput, date: OperandInput): FunctionNode => fn('DATE_TRUNC', [part, date]);
 
+/**
+ * Returns the difference between two timestamps as an interval.
+ * @param timestamp - The end timestamp.
+ * @param baseTimestamp - The start timestamp (optional, defaults to current time).
+ * @returns A FunctionNode representing the AGE SQL function.
+ */
+export const age = (timestamp: OperandInput, baseTimestamp?: OperandInput): FunctionNode =>
+    baseTimestamp === undefined ? fn('AGE', [timestamp]) : fn('AGE', [timestamp, baseTimestamp]);
+
+/**
+ * Extracts the hour from a date or datetime value.
+ * @param date - The date or datetime value.
+ * @returns A FunctionNode representing the HOUR SQL function.
+ */
+export const hour = (date: OperandInput): FunctionNode => fn('HOUR', [date]);
+
+/**
+ * Extracts the minute from a date or datetime value.
+ * @param date - The date or datetime value.
+ * @returns A FunctionNode representing the MINUTE SQL function.
+ */
+export const minute = (date: OperandInput): FunctionNode => fn('MINUTE', [date]);
+
+/**
+ * Extracts the second from a date or datetime value.
+ * @param date - The date or datetime value.
+ * @returns A FunctionNode representing the SECOND SQL function.
+ */
+export const second = (date: OperandInput): FunctionNode => fn('SECOND', [date]);
+
+/**
+ * Extracts the quarter from a date or datetime value (1-4).
+ * @param date - The date or datetime value.
+ * @returns A FunctionNode representing the QUARTER SQL function.
+ */
+export const quarter = (date: OperandInput): FunctionNode => fn('QUARTER', [date]);
+

package/src/core/functions/definitions/aggregate.ts

@@ -0,0 +1,16 @@
+import type { FunctionDefinition } from '../function-registry.js';
+import { unaryRenderer } from './helpers.js';
+
+export const aggregateFunctionDefinitions: FunctionDefinition[] = [
+  {
+    name: 'COUNT',
+    renderer: ({ compiledArgs }) =>
+      compiledArgs.length ? `COUNT(${compiledArgs.join(', ')})` : 'COUNT(*)'
+  },
+  { name: 'SUM', renderer: unaryRenderer('SUM') },
+  { name: 'AVG', renderer: unaryRenderer('AVG') },
+  { name: 'MIN', renderer: unaryRenderer('MIN') },
+  { name: 'MAX', renderer: unaryRenderer('MAX') },
+  { name: 'STDDEV', renderer: unaryRenderer('STDDEV') },
+  { name: 'VARIANCE', renderer: unaryRenderer('VARIANCE') }
+];

package/src/core/functions/definitions/control-flow.ts

@@ -0,0 +1,24 @@
+import type { FunctionDefinition } from '../function-registry.js';
+
+export const controlFlowFunctionDefinitions: FunctionDefinition[] = [
+  {
+    name: 'COALESCE',
+    renderer: ({ compiledArgs }) => `COALESCE(${compiledArgs.join(', ')})`
+  },
+  {
+    name: 'NULLIF',
+    renderer: ({ compiledArgs }) => `NULLIF(${compiledArgs[0]}, ${compiledArgs[1]})`
+  },
+  {
+    name: 'GREATEST',
+    renderer: ({ compiledArgs }) => `GREATEST(${compiledArgs.join(', ')})`
+  },
+  {
+    name: 'LEAST',
+    renderer: ({ compiledArgs }) => `LEAST(${compiledArgs.join(', ')})`
+  },
+  {
+    name: 'IFNULL',
+    renderer: ({ compiledArgs }) => `IFNULL(${compiledArgs[0]}, ${compiledArgs[1]})`
+  }
+];

package/src/core/functions/definitions/datetime.ts

@@ -0,0 +1,36 @@
+import type { FunctionDefinition } from '../function-registry.js';
+import { noArgsRenderer } from './helpers.js';
+
+export const dateTimeFunctionDefinitions: FunctionDefinition[] = [
+  { name: 'NOW', renderer: noArgsRenderer('NOW') },
+  { name: 'CURRENT_DATE', renderer: () => 'CURRENT_DATE' },
+  { name: 'CURRENT_TIME', renderer: () => 'CURRENT_TIME' },
+  {
+    name: 'EXTRACT',
+    renderer: ({ compiledArgs }) => `EXTRACT(${compiledArgs[0]} FROM ${compiledArgs[1]})`
+  },
+  { name: 'YEAR', renderer: ({ compiledArgs }) => `EXTRACT(YEAR FROM ${compiledArgs[0]})` },
+  { name: 'MONTH', renderer: ({ compiledArgs }) => `EXTRACT(MONTH FROM ${compiledArgs[0]})` },
+  { name: 'DAY', renderer: ({ compiledArgs }) => `EXTRACT(DAY FROM ${compiledArgs[0]})` },
+  { name: 'HOUR', renderer: ({ compiledArgs }) => `EXTRACT(HOUR FROM ${compiledArgs[0]})` },
+  { name: 'MINUTE', renderer: ({ compiledArgs }) => `EXTRACT(MINUTE FROM ${compiledArgs[0]})` },
+  { name: 'SECOND', renderer: ({ compiledArgs }) => `EXTRACT(SECOND FROM ${compiledArgs[0]})` },
+  { name: 'QUARTER', renderer: ({ compiledArgs }) => `EXTRACT(QUARTER FROM ${compiledArgs[0]})` },
+  { name: 'DATE_ADD', renderer: ({ compiledArgs }) => `(${compiledArgs[0]} + INTERVAL ${compiledArgs[1]} ${compiledArgs[2]})` },
+  { name: 'DATE_SUB', renderer: ({ compiledArgs }) => `(${compiledArgs[0]} - INTERVAL ${compiledArgs[1]} ${compiledArgs[2]})` },
+  { name: 'DATE_DIFF', renderer: ({ compiledArgs }) => `DATEDIFF(${compiledArgs[0]}, ${compiledArgs[1]})` },
+  { name: 'DATE_FORMAT', renderer: ({ compiledArgs }) => `DATE_FORMAT(${compiledArgs[0]}, ${compiledArgs[1]})` },
+  { name: 'UNIX_TIMESTAMP', renderer: noArgsRenderer('UNIX_TIMESTAMP') },
+  { name: 'FROM_UNIXTIME', renderer: ({ compiledArgs }) => `FROM_UNIXTIME(${compiledArgs[0]})` },
+  { name: 'END_OF_MONTH', renderer: ({ compiledArgs }) => `LAST_DAY(${compiledArgs[0]})` },
+  { name: 'DAY_OF_WEEK', renderer: ({ compiledArgs }) => `DAYOFWEEK(${compiledArgs[0]})` },
+  { name: 'WEEK_OF_YEAR', renderer: ({ compiledArgs }) => `WEEKOFYEAR(${compiledArgs[0]})` },
+  { name: 'DATE_TRUNC', renderer: ({ compiledArgs }) => `DATE_TRUNC(${compiledArgs[0]}, ${compiledArgs[1]})` },
+  {
+    name: 'AGE',
+    renderer: ({ compiledArgs }) =>
+      compiledArgs.length === 1 ? `AGE(${compiledArgs[0]})` : `AGE(${compiledArgs[0]}, ${compiledArgs[1]})`
+  },
+  { name: 'LOCALTIME', renderer: () => 'LOCALTIME' },
+  { name: 'LOCALTIMESTAMP', renderer: () => 'LOCALTIMESTAMP' }
+];

package/src/core/functions/definitions/helpers.ts

@@ -0,0 +1,29 @@
+import type { FunctionRenderer } from '../types.js';
+
+/**
+ * Simple renderer for functions that take one argument.
+ */
+export function unaryRenderer(name: string): FunctionRenderer {
+  return ({ compiledArgs }) => `${name}(${compiledArgs[0]})`;
+}
+
+/**
+ * Simple renderer for functions that take two arguments.
+ */
+export function binaryRenderer(name: string): FunctionRenderer {
+  return ({ compiledArgs }) => `${name}(${compiledArgs[0]}, ${compiledArgs[1]})`;
+}
+
+/**
+ * Renders functions that simply join all provided arguments.
+ */
+export function variadicRenderer(name: string): FunctionRenderer {
+  return ({ compiledArgs }) => `${name}(${compiledArgs.join(', ')})`;
+}
+
+/**
+ * Renders parameterless functions that always include parentheses.
+ */
+export function noArgsRenderer(name: string): FunctionRenderer {
+  return () => `${name}()`;
+}

package/src/core/functions/definitions/json.ts

@@ -0,0 +1,49 @@
+import type { FunctionDefinition } from '../function-registry.js';
+
+export const jsonFunctionDefinitions: FunctionDefinition[] = [
+  {
+    name: 'JSON_LENGTH',
+    renderer: ({ compiledArgs }) => {
+      if (compiledArgs.length === 0 || compiledArgs.length > 2) {
+        throw new Error('JSON_LENGTH expects 1 or 2 arguments');
+      }
+      return `JSON_LENGTH(${compiledArgs.join(', ')})`;
+    }
+  },
+  {
+    name: 'JSON_SET',
+    renderer: ({ compiledArgs }) => {
+      if (compiledArgs.length < 3 || (compiledArgs.length - 1) % 2 !== 0) {
+        throw new Error('JSON_SET expects a JSON document followed by one or more path/value pairs');
+      }
+      return `JSON_SET(${compiledArgs.join(', ')})`;
+    }
+  },
+  {
+    name: 'JSON_ARRAYAGG',
+    renderer: ({ compiledArgs }) => {
+      if (compiledArgs.length !== 1) {
+        throw new Error('JSON_ARRAYAGG expects exactly one argument');
+      }
+      return `JSON_ARRAYAGG(${compiledArgs[0]})`;
+    }
+  },
+  {
+    name: 'JSON_CONTAINS',
+    renderer: ({ compiledArgs }) => {
+      if (compiledArgs.length < 2 || compiledArgs.length > 3) {
+        throw new Error('JSON_CONTAINS expects two or three arguments');
+      }
+      return `JSON_CONTAINS(${compiledArgs.join(', ')})`;
+    }
+  },
+  {
+    name: 'ARRAY_APPEND',
+    renderer: ({ compiledArgs }) => {
+      if (compiledArgs.length !== 2) {
+        throw new Error('ARRAY_APPEND expects exactly two arguments');
+      }
+      return `ARRAY_APPEND(${compiledArgs[0]}, ${compiledArgs[1]})`;
+    }
+  }
+];

package/src/core/functions/definitions/numeric.ts

@@ -0,0 +1,55 @@
+import type { FunctionDefinition } from '../function-registry.js';
+import { binaryRenderer, noArgsRenderer, unaryRenderer } from './helpers.js';
+
+export const numericFunctionDefinitions: FunctionDefinition[] = [
+  { name: 'ABS', renderer: unaryRenderer('ABS') },
+  { name: 'BIT_LENGTH', renderer: unaryRenderer('BIT_LENGTH') },
+  { name: 'OCTET_LENGTH', renderer: unaryRenderer('OCTET_LENGTH') },
+  { name: 'CHR', renderer: unaryRenderer('CHR') },
+  { name: 'LOG2', renderer: unaryRenderer('LOG2') },
+  { name: 'CBRT', renderer: unaryRenderer('CBRT') },
+  { name: 'ACOS', renderer: unaryRenderer('ACOS') },
+  { name: 'ASIN', renderer: unaryRenderer('ASIN') },
+  { name: 'ATAN', renderer: unaryRenderer('ATAN') },
+  { name: 'ATAN2', renderer: binaryRenderer('ATAN2') },
+  { name: 'CEIL', renderer: unaryRenderer('CEIL') },
+  { name: 'CEILING', renderer: unaryRenderer('CEILING') },
+  { name: 'COS', renderer: unaryRenderer('COS') },
+  { name: 'COT', renderer: unaryRenderer('COT') },
+  { name: 'DEGREES', renderer: unaryRenderer('DEGREES') },
+  { name: 'EXP', renderer: unaryRenderer('EXP') },
+  { name: 'FLOOR', renderer: unaryRenderer('FLOOR') },
+  { name: 'LN', renderer: unaryRenderer('LN') },
+  {
+    name: 'LOG',
+    renderer: ({ compiledArgs }) =>
+      compiledArgs.length === 2 ? `LOG(${compiledArgs[0]}, ${compiledArgs[1]})` : `LOG(${compiledArgs[0]})`
+  },
+  { name: 'LOG10', renderer: unaryRenderer('LOG10') },
+  { name: 'LOG_BASE', renderer: binaryRenderer('LOG') },
+  { name: 'MOD', renderer: binaryRenderer('MOD') },
+  { name: 'PI', renderer: noArgsRenderer('PI') },
+  { name: 'POWER', renderer: binaryRenderer('POWER') },
+  { name: 'POW', renderer: binaryRenderer('POW') },
+  { name: 'RADIANS', renderer: unaryRenderer('RADIANS') },
+  { name: 'RANDOM', renderer: noArgsRenderer('RANDOM') },
+  { name: 'RAND', renderer: noArgsRenderer('RAND') },
+  {
+    name: 'ROUND',
+    renderer: ({ compiledArgs }) =>
+      compiledArgs.length === 2 ? `ROUND(${compiledArgs[0]}, ${compiledArgs[1]})` : `ROUND(${compiledArgs[0]})`
+  },
+  { name: 'SIGN', renderer: unaryRenderer('SIGN') },
+  { name: 'SIN', renderer: unaryRenderer('SIN') },
+  { name: 'SQRT', renderer: unaryRenderer('SQRT') },
+  { name: 'TAN', renderer: unaryRenderer('TAN') },
+  {
+    name: 'TRUNC',
+    renderer: ({ compiledArgs }) =>
+      compiledArgs.length === 2 ? `TRUNC(${compiledArgs[0]}, ${compiledArgs[1]})` : `TRUNC(${compiledArgs[0]})`
+  },
+  {
+    name: 'TRUNCATE',
+    renderer: ({ compiledArgs }) => `TRUNCATE(${compiledArgs[0]}, ${compiledArgs[1]})`
+  }
+];

package/src/core/functions/definitions/string.ts

@@ -0,0 +1,43 @@
+import type { FunctionDefinition } from '../function-registry.js';
+import { binaryRenderer, unaryRenderer, variadicRenderer } from './helpers.js';
+
+export const stringFunctionDefinitions: FunctionDefinition[] = [
+  { name: 'UPPER', renderer: unaryRenderer('UPPER') },
+  { name: 'LOWER', renderer: unaryRenderer('LOWER') },
+  { name: 'LENGTH', renderer: unaryRenderer('LENGTH') },
+  { name: 'CHAR_LENGTH', renderer: unaryRenderer('CHAR_LENGTH') },
+  { name: 'CHARACTER_LENGTH', renderer: unaryRenderer('CHARACTER_LENGTH') },
+  { name: 'TRIM', renderer: unaryRenderer('TRIM') },
+  { name: 'LTRIM', renderer: unaryRenderer('LTRIM') },
+  { name: 'RTRIM', renderer: unaryRenderer('RTRIM') },
+  { name: 'SUBSTRING', renderer: variadicRenderer('SUBSTRING') },
+  { name: 'SUBSTR', renderer: variadicRenderer('SUBSTR') },
+  { name: 'CONCAT', renderer: variadicRenderer('CONCAT') },
+  { name: 'CONCAT_WS', renderer: variadicRenderer('CONCAT_WS') },
+  { name: 'ASCII', renderer: unaryRenderer('ASCII') },
+  { name: 'CHAR', renderer: variadicRenderer('CHAR') },
+  {
+    name: 'POSITION',
+    renderer: ({ compiledArgs }) => `POSITION(${compiledArgs[0]} IN ${compiledArgs[1]})`
+  },
+  { name: 'REPLACE', renderer: ({ compiledArgs }) => `REPLACE(${compiledArgs[0]}, ${compiledArgs[1]}, ${compiledArgs[2]})` },
+  { name: 'REPEAT', renderer: binaryRenderer('REPEAT') },
+  { name: 'LPAD', renderer: ({ compiledArgs }) => `LPAD(${compiledArgs[0]}, ${compiledArgs[1]}, ${compiledArgs[2]})` },
+  { name: 'RPAD', renderer: ({ compiledArgs }) => `RPAD(${compiledArgs[0]}, ${compiledArgs[1]}, ${compiledArgs[2]})` },
+  { name: 'LEFT', renderer: binaryRenderer('LEFT') },
+  { name: 'RIGHT', renderer: binaryRenderer('RIGHT') },
+  { name: 'INSTR', renderer: binaryRenderer('INSTR') },
+  {
+    name: 'LOCATE',
+    renderer: ({ compiledArgs }) =>
+      compiledArgs.length === 3
+        ? `LOCATE(${compiledArgs[0]}, ${compiledArgs[1]}, ${compiledArgs[2]})`
+        : `LOCATE(${compiledArgs[0]}, ${compiledArgs[1]})`
+  },
+  { name: 'SPACE', renderer: unaryRenderer('SPACE') },
+  { name: 'REVERSE', renderer: unaryRenderer('REVERSE') },
+  { name: 'INITCAP', renderer: unaryRenderer('INITCAP') },
+  { name: 'MD5', renderer: unaryRenderer('MD5') },
+  { name: 'SHA1', renderer: unaryRenderer('SHA1') },
+  { name: 'SHA2', renderer: ({ compiledArgs }) => `SHA2(${compiledArgs[0]}, ${compiledArgs[1]})` }
+];

package/src/core/functions/function-registry.ts

@@ -0,0 +1,48 @@
+import type { FunctionRenderer } from './types.js';
+
+/**
+ * Definition for a SQL function renderer.
+ */
+export interface FunctionDefinition {
+  name: string;
+  renderer: FunctionRenderer;
+}
+
+/**
+ * Registry that keeps track of function renderers and exposes them by name.
+ */
+export class FunctionRegistry {
+  private readonly renderers: Map<string, FunctionRenderer> = new Map();
+
+  /**
+   * Registers or overrides a renderer for the given function name.
+   */
+  add(name: string, renderer: FunctionRenderer): void {
+    this.renderers.set(name, renderer);
+  }
+
+  /**
+   * Registers a batch of definitions.
+   */
+  register(definitions: Iterable<FunctionDefinition>): void {
+    for (const definition of definitions) {
+      this.add(definition.name, definition.renderer);
+    }
+  }
+
+  /**
+   * Merges another registry into this one, allowing overrides from the other source.
+   */
+  merge(other: FunctionRegistry): void {
+    for (const [name, renderer] of other.renderers.entries()) {
+      this.renderers.set(name, renderer);
+    }
+  }
+
+  /**
+   * Retrieves a renderer by function name.
+   */
+  get(name: string): FunctionRenderer | undefined {
+    return this.renderers.get(name);
+  }
+}

package/src/core/functions/group-concat-helpers.ts

@@ -0,0 +1,57 @@
+import type { FunctionRenderContext } from './types.js';
+import { isOperandNode, type LiteralNode, type OperandNode } from '../ast/expression.js';
+
+/** Default separator used when GROUP_CONCAT has no explicit separator. */
+export const DEFAULT_GROUP_CONCAT_SEPARATOR: LiteralNode = {
+  type: 'Literal',
+  value: ','
+};
+
+/**
+ * Builds an ORDER BY clause for functions that support ordering (e.g. GROUP_CONCAT).
+ */
+export function buildGroupConcatOrderBy(ctx: FunctionRenderContext): string {
+  const orderBy = ctx.node.orderBy;
+  if (!orderBy || orderBy.length === 0) {
+    return '';
+  }
+  const parts = orderBy.map(order => {
+    const term = isOperandNode(order.term)
+      ? ctx.compileOperand(order.term)
+      : (() => {
+          throw new Error('ORDER BY expressions inside functions must be operands');
+        })();
+    const collation = order.collation ? ` COLLATE ${order.collation}` : '';
+    const nulls = order.nulls ? ` NULLS ${order.nulls}` : '';
+    return `${term} ${order.direction}${collation}${nulls}`;
+  });
+  return `ORDER BY ${parts.join(', ')}`;
+}
+
+/**
+ * Formats the SEPARATOR clause for GROUP_CONCAT.
+ */
+export function formatGroupConcatSeparator(ctx: FunctionRenderContext): string {
+  if (!ctx.node.separator) {
+    return '';
+  }
+  return ` SEPARATOR ${ctx.compileOperand(ctx.node.separator)}`;
+}
+
+/**
+ * Returns the operand used as the separator for GROUP_CONCAT.
+ */
+export function getGroupConcatSeparatorOperand(ctx: FunctionRenderContext): OperandNode {
+  return ctx.node.separator ?? DEFAULT_GROUP_CONCAT_SEPARATOR;
+}
+
+/**
+ * Renders the default GROUP_CONCAT statement.
+ */
+export function renderStandardGroupConcat(ctx: FunctionRenderContext): string {
+  const arg = ctx.compiledArgs[0];
+  const orderClause = buildGroupConcatOrderBy(ctx);
+  const orderSegment = orderClause ? ` ${orderClause}` : '';
+  const separatorClause = formatGroupConcatSeparator(ctx);
+  return `GROUP_CONCAT(${arg}${orderSegment}${separatorClause})`;
+}

package/src/core/functions/json.ts

@@ -0,0 +1,38 @@
+// Pure AST Builders - No Dialect Logic Here!
+
+import { ColumnDef } from '../../schema/column-types.js';
+import { columnOperand, valueToOperand } from '../ast/expression-builders.js';
+import { FunctionNode, OperandNode, isOperandNode } from '../ast/expression.js';
+
+type OperandInput = OperandNode | ColumnDef | string | number | boolean | null;
+
+const isColumnDef = (val: unknown): val is ColumnDef => !!val && typeof val === 'object' && 'type' in val && 'name' in val;
+
+const toOperand = (input: OperandInput): OperandNode => {
+    if (isOperandNode(input)) return input;
+    if (isColumnDef(input)) return columnOperand(input);
+
+    return valueToOperand(input);
+};
+
+const fn = (key: string, args: OperandInput[]): FunctionNode => ({
+    type: 'Function',
+    name: key,
+    fn: key,
+    args: args.map(toOperand)
+});
+
+export const jsonLength = (target: OperandInput, path?: OperandInput): FunctionNode =>
+    path === undefined ? fn('JSON_LENGTH', [target]) : fn('JSON_LENGTH', [target, path]);
+
+export const jsonSet = (target: OperandInput, path: OperandInput, value: OperandInput): FunctionNode =>
+    fn('JSON_SET', [target, path, value]);
+
+export const jsonArrayAgg = (value: OperandInput): FunctionNode => fn('JSON_ARRAYAGG', [value]);
+
+export const jsonContains = (
+    target: OperandInput,
+    candidate: OperandInput,
+    path?: OperandInput
+): FunctionNode =>
+    path === undefined ? fn('JSON_CONTAINS', [target, candidate]) : fn('JSON_CONTAINS', [target, candidate, path]);

package/src/core/functions/numeric.ts

@@ -244,3 +244,17 @@ export const trunc = (value: OperandInput, decimals?: OperandInput): FunctionNod
 export const truncate = (value: OperandInput, decimals: OperandInput): FunctionNode =>
     fn('TRUNCATE', [value, decimals]);
 
+/**
+ * Returns the base-2 logarithm of a number.
+ * @param value - The numeric value.
+ * @returns A FunctionNode representing the LOG2 SQL function.
+ */
+export const log2 = (value: OperandInput): FunctionNode => fn('LOG2', [value]);
+
+/**
+ * Returns the cube root of a number.
+ * @param value - The numeric value.
+ * @returns A FunctionNode representing the CBRT SQL function.
+ */
+export const cbrt = (value: OperandInput): FunctionNode => fn('CBRT', [value]);
+