metal-orm 1.0.56 → 1.0.57

package/dist/index.cjs

@@ -2,8 +2,8 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn5, res) => function __init() {
-  return fn5 && (res = (0, fn5[__getOwnPropNames(fn5)[0]])(fn5 = 0)), res;
+var __esm = (fn8, res) => function __init() {
+  return fn8 && (res = (0, fn8[__getOwnPropNames(fn8)[0]])(fn8 = 0)), res;
 };
 var __export = (target, all) => {
   for (var name in all)
@@ -74,8 +74,10 @@ __export(index_exports, {
   acos: () => acos,
   add: () => add,
   addDomainEvent: () => addDomainEvent,
+  age: () => age,
   aliasRef: () => aliasRef,
   and: () => and,
+  arrayAppend: () => arrayAppend,
   ascii: () => ascii,
   asin: () => asin,
   atan: () => atan,
@@ -84,16 +86,24 @@ __export(index_exports, {
   belongsTo: () => belongsTo,
   belongsToMany: () => belongsToMany,
   between: () => between,
+  bitAnd: () => bitAnd,
+  bitLength: () => bitLength,
+  bitOr: () => bitOr,
+  bitXor: () => bitXor,
   bootstrapEntities: () => bootstrapEntities,
   caseWhen: () => caseWhen,
   cast: () => cast,
+  cbrt: () => cbrt,
   ceil: () => ceil,
   ceiling: () => ceiling,
   char: () => char,
   charLength: () => charLength,
+  chr: () => chr,
   clearExpressionDispatchers: () => clearExpressionDispatchers,
   clearOperandDispatchers: () => clearOperandDispatchers,
+  coalesce: () => coalesce,
   col: () => col,
+  collate: () => collate,
   columnOperand: () => columnOperand,
   concat: () => concat,
   concatWs: () => concatWs,
@@ -145,18 +155,23 @@ __export(index_exports, {
   getDecoratorMetadata: () => getDecoratorMetadata,
   getSchemaIntrospector: () => getSchemaIntrospector,
   getTableDefFromEntity: () => getTableDefFromEntity,
+  greatest: () => greatest,
   groupConcat: () => groupConcat,
   gt: () => gt,
   gte: () => gte,
   hasMany: () => hasMany,
   hasOne: () => hasOne,
+  hour: () => hour,
   hydrateRows: () => hydrateRows,
+  ifNull: () => ifNull,
   inList: () => inList,
   inSubquery: () => inSubquery,
+  initcap: () => initcap,
   instr: () => instr,
   introspectSchema: () => introspectSchema,
   isCaseExpressionNode: () => isCaseExpressionNode,
   isCastExpressionNode: () => isCastExpressionNode,
+  isCollateExpressionNode: () => isCollateExpressionNode,
   isExpressionSelectionNode: () => isExpressionSelectionNode,
   isFunctionNode: () => isFunctionNode,
   isNotNull: () => isNotNull,
@@ -164,11 +179,16 @@ __export(index_exports, {
   isOperandNode: () => isOperandNode,
   isValueOperandInput: () => isValueOperandInput,
   isWindowFunctionNode: () => isWindowFunctionNode,
+  jsonArrayAgg: () => jsonArrayAgg,
+  jsonContains: () => jsonContains,
+  jsonLength: () => jsonLength,
   jsonPath: () => jsonPath,
+  jsonSet: () => jsonSet,
   jsonify: () => jsonify,
   lag: () => lag,
   lastValue: () => lastValue,
   lead: () => lead,
+  least: () => least,
   left: () => left,
   length: () => length,
   like: () => like,
@@ -177,9 +197,12 @@ __export(index_exports, {
   loadBelongsToRelation: () => loadBelongsToRelation,
   loadHasManyRelation: () => loadHasManyRelation,
   loadHasOneRelation: () => loadHasOneRelation,
+  localTime: () => localTime,
+  localTimestamp: () => localTimestamp,
   locate: () => locate,
   log: () => log,
   log10: () => log10,
+  log2: () => log2,
   logBase: () => logBase,
   lower: () => lower,
   lpad: () => lpad,
@@ -187,7 +210,9 @@ __export(index_exports, {
   lte: () => lte,
   ltrim: () => ltrim,
   max: () => max,
+  md5: () => md5,
   min: () => min,
+  minute: () => minute,
   mod: () => mod,
   month: () => month,
   mul: () => mul,
@@ -200,12 +225,15 @@ __export(index_exports, {
   notLike: () => notLike,
   now: () => now,
   ntile: () => ntile,
+  nullif: () => nullif,
+  octetLength: () => octetLength,
   or: () => or,
   outerRef: () => outerRef,
   pi: () => pi,
   position: () => position,
   pow: () => pow,
   power: () => power,
+  quarter: () => quarter,
   radians: () => radians,
   rand: () => rand,
   random: () => random,
@@ -217,18 +245,25 @@ __export(index_exports, {
   renderTypeWithArgs: () => renderTypeWithArgs,
   repeat: () => repeat,
   replace: () => replace,
+  reverse: () => reverse,
   right: () => right,
   round: () => round,
   rowNumber: () => rowNumber,
   rowsToQueryResult: () => rowsToQueryResult,
   rpad: () => rpad,
   rtrim: () => rtrim,
+  second: () => second,
   sel: () => sel,
   selectFromEntity: () => selectFromEntity,
+  sha1: () => sha1,
+  sha2: () => sha2,
+  shiftLeft: () => shiftLeft,
+  shiftRight: () => shiftRight,
   sign: () => sign,
   sin: () => sin,
   space: () => space,
   sqrt: () => sqrt,
+  stddev: () => stddev,
   sub: () => sub,
   substr: () => substr,
   sum: () => sum,
@@ -244,6 +279,7 @@ __export(index_exports, {
   upper: () => upper,
   utcNow: () => utcNow,
   valueToOperand: () => valueToOperand,
+  variance: () => variance,
   visitExpression: () => visitExpression,
   visitOperand: () => visitOperand,
   weekOfYear: () => weekOfYear,
@@ -586,7 +622,9 @@ var operandTypes = /* @__PURE__ */ new Set([
   "CaseExpression",
   "Cast",
   "WindowFunction",
-  "ArithmeticExpression"
+  "ArithmeticExpression",
+  "BitwiseExpression",
+  "Collate"
 ]);
 var hasTypeProperty = (value) => typeof value === "object" && value !== null && "type" in value;
 var isOperandNode = (node) => {
@@ -596,6 +634,7 @@ var isOperandNode = (node) => {
 var isFunctionNode = (node) => isOperandNode(node) && node.type === "Function";
 var isCaseExpressionNode = (node) => isOperandNode(node) && node.type === "CaseExpression";
 var isCastExpressionNode = (node) => isOperandNode(node) && node.type === "Cast";
+var isCollateExpressionNode = (node) => isOperandNode(node) && node.type === "Collate";
 var isWindowFunctionNode = (node) => isOperandNode(node) && node.type === "WindowFunction";
 var isExpressionSelectionNode = (node) => isFunctionNode(node) || isCaseExpressionNode(node) || isCastExpressionNode(node) || isWindowFunctionNode(node);
 
@@ -720,6 +759,17 @@ var add = (left2, right2) => createArithmeticExpression("+", left2, right2);
 var sub = (left2, right2) => createArithmeticExpression("-", left2, right2);
 var mul = (left2, right2) => createArithmeticExpression("*", left2, right2);
 var div = (left2, right2) => createArithmeticExpression("/", left2, right2);
+var createBitwiseExpression = (operator, left2, right2) => ({
+  type: "BitwiseExpression",
+  left: toOperand(left2),
+  operator,
+  right: toOperand(right2)
+});
+var bitAnd = (left2, right2) => createBitwiseExpression("&", left2, right2);
+var bitOr = (left2, right2) => createBitwiseExpression("|", left2, right2);
+var bitXor = (left2, right2) => createBitwiseExpression("^", left2, right2);
+var shiftLeft = (left2, right2) => createBitwiseExpression("<<", left2, right2);
+var shiftRight = (left2, right2) => createBitwiseExpression(">>", left2, right2);
 var jsonPath = (col2, path) => ({
   type: "JsonPath",
   column: columnOperand(col2),
@@ -748,6 +798,11 @@ var notExists = (subquery) => ({
   operator: "NOT EXISTS",
   subquery
 });
+var collate = (expression, collation) => ({
+  type: "Collate",
+  expression: toOperand(expression),
+  collation
+});
 
 // src/core/ast/window-functions.ts
 var buildWindowFunction = (name, args = [], partitionBy, orderBy) => {
@@ -893,6 +948,8 @@ var groupConcat = (col2, options) => ({
   orderBy: options?.orderBy?.map(toOrderByNode),
   separator: options?.separator !== void 0 ? valueToOperand(options.separator) : void 0
 });
+var stddev = buildAggregate("STDDEV");
+var variance = buildAggregate("VARIANCE");
 
 // src/core/ast/expression-visitor.ts
 var DispatcherRegistry = class _DispatcherRegistry {
@@ -966,6 +1023,9 @@ var visitExpression = (node, visitor) => {
     case "ArithmeticExpression":
       if (visitor.visitArithmeticExpression) return visitor.visitArithmeticExpression(node);
       break;
+    case "BitwiseExpression":
+      if (visitor.visitBitwiseExpression) return visitor.visitBitwiseExpression(node);
+      break;
     default:
       break;
   }
@@ -1003,6 +1063,9 @@ var visitOperand = (node, visitor) => {
     case "Cast":
       if (visitor.visitCast) return visitor.visitCast(node);
       break;
+    case "Collate":
+      if (visitor.visitCollate) return visitor.visitCollate(node);
+      break;
     default:
       break;
   }
@@ -1073,62 +1136,337 @@ var derivedTable = (query, alias, columnAliases) => ({
   columnAliases
 });
 
+// src/core/functions/function-registry.ts
+var FunctionRegistry = class {
+  constructor() {
+    this.renderers = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Registers or overrides a renderer for the given function name.
+   */
+  add(name, renderer) {
+    this.renderers.set(name, renderer);
+  }
+  /**
+   * Registers a batch of definitions.
+   */
+  register(definitions) {
+    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) {
+    for (const [name, renderer] of other.renderers.entries()) {
+      this.renderers.set(name, renderer);
+    }
+  }
+  /**
+   * Retrieves a renderer by function name.
+   */
+  get(name) {
+    return this.renderers.get(name);
+  }
+};
+
+// src/core/functions/definitions/helpers.ts
+function unaryRenderer(name) {
+  return ({ compiledArgs }) => `${name}(${compiledArgs[0]})`;
+}
+function binaryRenderer(name) {
+  return ({ compiledArgs }) => `${name}(${compiledArgs[0]}, ${compiledArgs[1]})`;
+}
+function variadicRenderer(name) {
+  return ({ compiledArgs }) => `${name}(${compiledArgs.join(", ")})`;
+}
+function noArgsRenderer(name) {
+  return () => `${name}()`;
+}
+
+// src/core/functions/definitions/aggregate.ts
+var aggregateFunctionDefinitions = [
+  {
+    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") }
+];
+
+// src/core/functions/definitions/string.ts
+var stringFunctionDefinitions = [
+  { 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]})` }
+];
+
+// src/core/functions/definitions/datetime.ts
+var dateTimeFunctionDefinitions = [
+  { 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" }
+];
+
+// src/core/functions/definitions/numeric.ts
+var numericFunctionDefinitions = [
+  { 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]})`
+  }
+];
+
+// src/core/functions/definitions/control-flow.ts
+var controlFlowFunctionDefinitions = [
+  {
+    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]})`
+  }
+];
+
+// src/core/functions/definitions/json.ts
+var jsonFunctionDefinitions = [
+  {
+    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]})`;
+    }
+  }
+];
+
+// src/core/functions/group-concat-helpers.ts
+var DEFAULT_GROUP_CONCAT_SEPARATOR = {
+  type: "Literal",
+  value: ","
+};
+function buildGroupConcatOrderBy(ctx) {
+  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(", ")}`;
+}
+function formatGroupConcatSeparator(ctx) {
+  if (!ctx.node.separator) {
+    return "";
+  }
+  return ` SEPARATOR ${ctx.compileOperand(ctx.node.separator)}`;
+}
+function getGroupConcatSeparatorOperand(ctx) {
+  return ctx.node.separator ?? DEFAULT_GROUP_CONCAT_SEPARATOR;
+}
+function renderStandardGroupConcat(ctx) {
+  const arg = ctx.compiledArgs[0];
+  const orderClause = buildGroupConcatOrderBy(ctx);
+  const orderSegment = orderClause ? ` ${orderClause}` : "";
+  const separatorClause = formatGroupConcatSeparator(ctx);
+  return `GROUP_CONCAT(${arg}${orderSegment}${separatorClause})`;
+}
+
 // src/core/functions/standard-strategy.ts
-var StandardFunctionStrategy = class _StandardFunctionStrategy {
+var StandardFunctionStrategy = class {
   /**
    * Creates a new StandardFunctionStrategy and registers standard functions.
    */
-  constructor() {
-    this.renderers = /* @__PURE__ */ new Map();
+  constructor(registry2) {
+    this.registry = registry2 ?? new FunctionRegistry();
     this.registerStandard();
   }
   registerStandard() {
-    this.add("COUNT", ({ compiledArgs }) => compiledArgs.length ? `COUNT(${compiledArgs.join(", ")})` : "COUNT(*)");
-    this.add("SUM", ({ compiledArgs }) => `SUM(${compiledArgs[0]})`);
-    this.add("AVG", ({ compiledArgs }) => `AVG(${compiledArgs[0]})`);
-    this.add("MIN", ({ compiledArgs }) => `MIN(${compiledArgs[0]})`);
-    this.add("MAX", ({ compiledArgs }) => `MAX(${compiledArgs[0]})`);
-    this.add("ABS", ({ compiledArgs }) => `ABS(${compiledArgs[0]})`);
-    this.add("UPPER", ({ compiledArgs }) => `UPPER(${compiledArgs[0]})`);
-    this.add("LOWER", ({ compiledArgs }) => `LOWER(${compiledArgs[0]})`);
-    this.add("LENGTH", ({ compiledArgs }) => `LENGTH(${compiledArgs[0]})`);
-    this.add("TRIM", ({ compiledArgs }) => `TRIM(${compiledArgs[0]})`);
-    this.add("LTRIM", ({ compiledArgs }) => `LTRIM(${compiledArgs[0]})`);
-    this.add("RTRIM", ({ compiledArgs }) => `RTRIM(${compiledArgs[0]})`);
-    this.add("SUBSTRING", ({ compiledArgs }) => `SUBSTRING(${compiledArgs.join(", ")})`);
-    this.add("CONCAT", ({ compiledArgs }) => `CONCAT(${compiledArgs.join(", ")})`);
-    this.add("NOW", () => `NOW()`);
-    this.add("CURRENT_DATE", () => `CURRENT_DATE`);
-    this.add("CURRENT_TIME", () => `CURRENT_TIME`);
-    this.add("EXTRACT", ({ compiledArgs }) => `EXTRACT(${compiledArgs[0]} FROM ${compiledArgs[1]})`);
-    this.add("YEAR", ({ compiledArgs }) => `EXTRACT(YEAR FROM ${compiledArgs[0]})`);
-    this.add("MONTH", ({ compiledArgs }) => `EXTRACT(MONTH FROM ${compiledArgs[0]})`);
-    this.add("DAY", ({ compiledArgs }) => `EXTRACT(DAY FROM ${compiledArgs[0]})`);
-    this.add("DATE_ADD", ({ compiledArgs }) => `(${compiledArgs[0]} + INTERVAL ${compiledArgs[1]} ${compiledArgs[2]})`);
-    this.add("DATE_SUB", ({ compiledArgs }) => `(${compiledArgs[0]} - INTERVAL ${compiledArgs[1]} ${compiledArgs[2]})`);
-    this.add("DATE_DIFF", ({ compiledArgs }) => `DATEDIFF(${compiledArgs[0]}, ${compiledArgs[1]})`);
-    this.add("DATE_FORMAT", ({ compiledArgs }) => `DATE_FORMAT(${compiledArgs[0]}, ${compiledArgs[1]})`);
-    this.add("UNIX_TIMESTAMP", () => `UNIX_TIMESTAMP()`);
-    this.add("FROM_UNIXTIME", ({ compiledArgs }) => `FROM_UNIXTIME(${compiledArgs[0]})`);
-    this.add("END_OF_MONTH", ({ compiledArgs }) => `LAST_DAY(${compiledArgs[0]})`);
-    this.add("DAY_OF_WEEK", ({ compiledArgs }) => `DAYOFWEEK(${compiledArgs[0]})`);
-    this.add("WEEK_OF_YEAR", ({ compiledArgs }) => `WEEKOFYEAR(${compiledArgs[0]})`);
-    this.add("DATE_TRUNC", ({ compiledArgs }) => `DATE_TRUNC(${compiledArgs[0]}, ${compiledArgs[1]})`);
+    this.registerDefinitions(aggregateFunctionDefinitions);
+    this.registerDefinitions(stringFunctionDefinitions);
+    this.registerDefinitions(dateTimeFunctionDefinitions);
+    this.registerDefinitions(numericFunctionDefinitions);
+    this.registerDefinitions(controlFlowFunctionDefinitions);
+    this.registerDefinitions(jsonFunctionDefinitions);
     this.add("GROUP_CONCAT", (ctx) => this.renderGroupConcat(ctx));
   }
+  registerDefinitions(definitions) {
+    this.registry.register(definitions);
+  }
   /**
    * Registers a renderer for a function name.
    * @param name - The function name.
    * @param renderer - The renderer function.
    */
   add(name, renderer) {
-    this.renderers.set(name, renderer);
+    this.registry.add(name, renderer);
   }
   /**
    * @inheritDoc
    */
   getRenderer(name) {
-    return this.renderers.get(name);
+    return this.registry.get(name);
   }
   /**
    * Renders the GROUP_CONCAT function with optional ORDER BY and SEPARATOR.
@@ -1136,11 +1474,7 @@ var StandardFunctionStrategy = class _StandardFunctionStrategy {
    * @returns The rendered SQL string.
    */
   renderGroupConcat(ctx) {
-    const arg = ctx.compiledArgs[0];
-    const orderClause = this.buildOrderByExpression(ctx);
-    const orderSegment = orderClause ? ` ${orderClause}` : "";
-    const separatorClause = this.formatGroupConcatSeparator(ctx);
-    return `GROUP_CONCAT(${arg}${orderSegment}${separatorClause})`;
+    return renderStandardGroupConcat(ctx);
   }
   /**
    * Builds the ORDER BY clause for functions like GROUP_CONCAT.
@@ -1148,19 +1482,7 @@ var StandardFunctionStrategy = class _StandardFunctionStrategy {
    * @returns The ORDER BY SQL clause or empty string.
    */
   buildOrderByExpression(ctx) {
-    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(", ")}`;
+    return buildGroupConcatOrderBy(ctx);
   }
   /**
    * Formats the SEPARATOR clause for GROUP_CONCAT.
@@ -1168,10 +1490,7 @@ var StandardFunctionStrategy = class _StandardFunctionStrategy {
    * @returns The SEPARATOR SQL clause or empty string.
    */
   formatGroupConcatSeparator(ctx) {
-    if (!ctx.node.separator) {
-      return "";
-    }
-    return ` SEPARATOR ${ctx.compileOperand(ctx.node.separator)}`;
+    return formatGroupConcatSeparator(ctx);
   }
   /**
    * Gets the separator operand for GROUP_CONCAT, defaulting to comma.
@@ -1179,14 +1498,24 @@ var StandardFunctionStrategy = class _StandardFunctionStrategy {
    * @returns The separator operand.
    */
   getGroupConcatSeparatorOperand(ctx) {
-    return ctx.node.separator ?? _StandardFunctionStrategy.DEFAULT_GROUP_CONCAT_SEPARATOR;
+    return getGroupConcatSeparatorOperand(ctx);
   }
   static {
     /** Default separator for GROUP_CONCAT, a comma. */
-    this.DEFAULT_GROUP_CONCAT_SEPARATOR = {
-      type: "Literal",
-      value: ","
-    };
+    this.DEFAULT_GROUP_CONCAT_SEPARATOR = DEFAULT_GROUP_CONCAT_SEPARATOR;
+  }
+};
+
+// src/core/functions/standard-table-strategy.ts
+var StandardTableFunctionStrategy = class {
+  constructor() {
+    this.renderers = /* @__PURE__ */ new Map();
+  }
+  add(key, renderer) {
+    this.renderers.set(key, renderer);
+  }
+  getRenderer(key) {
+    return this.renderers.get(key);
   }
 };
 
@@ -1360,10 +1689,11 @@ var Dialect = class _Dialect {
     const combinedCtes = [...normalized.ctes ?? [], ...hoistedCtes];
     return combinedCtes.length ? { ...normalized, ctes: combinedCtes } : normalized;
   }
-  constructor(functionStrategy) {
+  constructor(functionStrategy, tableFunctionStrategy) {
     this.expressionCompilers = /* @__PURE__ */ new Map();
     this.operandCompilers = /* @__PURE__ */ new Map();
     this.functionStrategy = functionStrategy || new StandardFunctionStrategy();
+    this.tableFunctionStrategy = tableFunctionStrategy || new StandardTableFunctionStrategy();
     this.registerDefaultOperandCompilers();
     this.registerDefaultExpressionCompilers();
   }
@@ -1372,7 +1702,7 @@ var Dialect = class _Dialect {
    * @param functionStrategy - Optional function strategy
    * @returns New Dialect instance
    */
-  static create(functionStrategy) {
+  static create(functionStrategy, tableFunctionStrategy) {
     class TestDialect extends _Dialect {
       constructor() {
         super(...arguments);
@@ -1394,7 +1724,7 @@ var Dialect = class _Dialect {
         throw new Error("Not implemented");
       }
     }
-    return new TestDialect(functionStrategy);
+    return new TestDialect(functionStrategy, tableFunctionStrategy);
   }
   /**
    * Registers an expression compiler for a specific node type
@@ -1495,6 +1825,11 @@ var Dialect = class _Dialect {
       const right2 = this.compileOperand(arith.right, ctx);
       return `${left2} ${arith.operator} ${right2}`;
     });
+    this.registerExpressionCompiler("BitwiseExpression", (bitwise, ctx) => {
+      const left2 = this.compileOperand(bitwise.left, ctx);
+      const right2 = this.compileOperand(bitwise.right, ctx);
+      return `${left2} ${bitwise.operator} ${right2}`;
+    });
   }
   registerDefaultOperandCompilers() {
     this.registerOperandCompiler("Literal", (literal, ctx) => ctx.addParameter(literal.value));
@@ -1564,6 +1899,15 @@ var Dialect = class _Dialect {
       const right2 = this.compileOperand(node.right, ctx);
       return `(${left2} ${node.operator} ${right2})`;
     });
+    this.registerOperandCompiler("BitwiseExpression", (node, ctx) => {
+      const left2 = this.compileOperand(node.left, ctx);
+      const right2 = this.compileOperand(node.right, ctx);
+      return `(${left2} ${node.operator} ${right2})`;
+    });
+    this.registerOperandCompiler("Collate", (node, ctx) => {
+      const expr = this.compileOperand(node.expression, ctx);
+      return `${expr} COLLATE ${node.collation}`;
+    });
   }
   // Default fallback, should be overridden by dialects if supported
   compileJsonPath(_node) {
@@ -1596,13 +1940,13 @@ var FunctionTableFormatter = class {
    * @param dialect - The dialect instance for compiling operands.
    * @returns SQL function table expression (e.g., "LATERAL schema.func(args) WITH ORDINALITY AS alias(col1, col2)").
    */
-  static format(fn5, ctx, dialect) {
-    const schemaPart = this.formatSchema(fn5, dialect);
-    const args = this.formatArgs(fn5, ctx, dialect);
-    const base = this.formatBase(fn5, schemaPart, args, dialect);
-    const lateral = this.formatLateral(fn5);
-    const alias = this.formatAlias(fn5, dialect);
-    const colAliases = this.formatColumnAliases(fn5, dialect);
+  static format(fn8, ctx, dialect) {
+    const schemaPart = this.formatSchema(fn8, dialect);
+    const args = this.formatArgs(fn8, ctx, dialect);
+    const base = this.formatBase(fn8, schemaPart, args);
+    const lateral = this.formatLateral(fn8);
+    const alias = this.formatAlias(fn8, dialect);
+    const colAliases = this.formatColumnAliases(fn8, dialect);
     return `${lateral}${base}${alias}${colAliases}`;
   }
   /**
@@ -1612,9 +1956,9 @@ var FunctionTableFormatter = class {
    * @returns Schema prefix (e.g., "schema.") or empty string.
    * @internal
    */
-  static formatSchema(fn5, dialect) {
-    if (!fn5.schema) return "";
-    const quoted = dialect ? dialect.quoteIdentifier(fn5.schema) : fn5.schema;
+  static formatSchema(fn8, dialect) {
+    if (!fn8.schema) return "";
+    const quoted = dialect ? dialect.quoteIdentifier(fn8.schema) : fn8.schema;
     return `${quoted}.`;
   }
   /**
@@ -1625,8 +1969,8 @@ var FunctionTableFormatter = class {
    * @returns Comma-separated function arguments.
    * @internal
    */
-  static formatArgs(fn5, ctx, dialect) {
-    return (fn5.args || []).map((a) => {
+  static formatArgs(fn8, ctx, dialect) {
+    return (fn8.args || []).map((a) => {
       if (ctx && dialect) {
         return dialect.compileOperand(a, ctx);
       }
@@ -1642,10 +1986,9 @@ var FunctionTableFormatter = class {
    * @returns Base function call expression (e.g., "schema.func(args) WITH ORDINALITY").
    * @internal
    */
-  static formatBase(fn5, schemaPart, args, dialect) {
-    const ordinality = fn5.withOrdinality ? " WITH ORDINALITY" : "";
-    const quoted = dialect ? dialect.quoteIdentifier(fn5.name) : fn5.name;
-    return `${schemaPart}${quoted}(${args})${ordinality}`;
+  static formatBase(fn8, schemaPart, args) {
+    const ordinality = fn8.withOrdinality ? " WITH ORDINALITY" : "";
+    return `${schemaPart}${fn8.name}(${args})${ordinality}`;
   }
   /**
    * Formats the LATERAL keyword if present.
@@ -1653,8 +1996,8 @@ var FunctionTableFormatter = class {
    * @returns "LATERAL " or empty string.
    * @internal
    */
-  static formatLateral(fn5) {
-    return fn5.lateral ? "LATERAL " : "";
+  static formatLateral(fn8) {
+    return fn8.lateral ? "LATERAL " : "";
   }
   /**
    * Formats the table alias for the function table.
@@ -1663,9 +2006,9 @@ var FunctionTableFormatter = class {
    * @returns " AS alias" or empty string.
    * @internal
    */
-  static formatAlias(fn5, dialect) {
-    if (!fn5.alias) return "";
-    const quoted = dialect ? dialect.quoteIdentifier(fn5.alias) : fn5.alias;
+  static formatAlias(fn8, dialect) {
+    if (!fn8.alias) return "";
+    const quoted = dialect ? dialect.quoteIdentifier(fn8.alias) : fn8.alias;
     return ` AS ${quoted}`;
   }
   /**
@@ -1675,9 +2018,9 @@ var FunctionTableFormatter = class {
    * @returns "(col1, col2, ...)" or empty string.
    * @internal
    */
-  static formatColumnAliases(fn5, dialect) {
-    if (!fn5.columnAliases || !fn5.columnAliases.length) return "";
-    const aliases = fn5.columnAliases.map((col2) => dialect ? dialect.quoteIdentifier(col2) : col2).join(", ");
+  static formatColumnAliases(fn8, dialect) {
+    if (!fn8.columnAliases || !fn8.columnAliases.length) return "";
+    const aliases = fn8.columnAliases.map((col2) => dialect ? dialect.quoteIdentifier(col2) : col2).join(", ");
     return `(${aliases})`;
   }
 };
@@ -1945,8 +2288,24 @@ var SqlDialectBase = class extends Dialect {
     }
     return this.compileTableSource(tableSource);
   }
-  compileFunctionTable(fn5, ctx) {
-    return FunctionTableFormatter.format(fn5, ctx, this);
+  compileFunctionTable(fn8, ctx) {
+    const key = fn8.key ?? fn8.name;
+    if (ctx) {
+      const renderer = this.tableFunctionStrategy.getRenderer(key);
+      if (renderer) {
+        const compiledArgs = (fn8.args ?? []).map((arg) => this.compileOperand(arg, ctx));
+        return renderer({
+          node: fn8,
+          compiledArgs,
+          compileOperand: (operand) => this.compileOperand(operand, ctx),
+          quoteIdentifier: this.quoteIdentifier.bind(this)
+        });
+      }
+      if (fn8.key) {
+        throw new Error(`Table function "${key}" is not supported by dialect "${this.dialect}".`);
+      }
+    }
+    return FunctionTableFormatter.format(fn8, ctx, this);
   }
   compileDerivedTable(table, ctx) {
     if (!table.alias) {
@@ -2105,6 +2464,76 @@ var PostgresFunctionStrategy = class extends StandardFunctionStrategy {
       const separator = ctx.compileOperand(separatorOperand);
       return `STRING_AGG(${arg}, ${separator}${orderSegment})`;
     });
+    this.add("CHR", ({ compiledArgs }) => `CHR(${compiledArgs[0]})`);
+    this.add("HOUR", ({ compiledArgs }) => `EXTRACT(HOUR FROM ${compiledArgs[0]})`);
+    this.add("MINUTE", ({ compiledArgs }) => `EXTRACT(MINUTE FROM ${compiledArgs[0]})`);
+    this.add("SECOND", ({ compiledArgs }) => `EXTRACT(SECOND FROM ${compiledArgs[0]})`);
+    this.add("QUARTER", ({ compiledArgs }) => `EXTRACT(QUARTER FROM ${compiledArgs[0]})`);
+    this.add("JSON_LENGTH", ({ compiledArgs }) => {
+      if (compiledArgs.length !== 1) throw new Error("JSON_LENGTH expects 1 argument on PostgreSQL");
+      return `jsonb_array_length(${compiledArgs[0]})`;
+    });
+    this.add("JSON_ARRAYAGG", ({ compiledArgs }) => {
+      if (compiledArgs.length !== 1) throw new Error("JSON_ARRAYAGG expects 1 argument on PostgreSQL");
+      return `jsonb_agg(${compiledArgs[0]})`;
+    });
+    this.add("JSON_CONTAINS", ({ compiledArgs }) => {
+      if (compiledArgs.length !== 2) throw new Error("JSON_CONTAINS expects 2 arguments on PostgreSQL");
+      return `(${compiledArgs[0]}::jsonb @> ${compiledArgs[1]}::jsonb)`;
+    });
+    this.add("ARRAY_APPEND", ({ compiledArgs }) => {
+      if (compiledArgs.length !== 2) throw new Error("ARRAY_APPEND expects 2 arguments on PostgreSQL");
+      return `array_append(${compiledArgs[0]}, ${compiledArgs[1]})`;
+    });
+    this.add("JSON_SET", ({ node, compiledArgs }) => {
+      if (compiledArgs.length !== 3) throw new Error("JSON_SET expects exactly 3 arguments on PostgreSQL");
+      const pathNode = node.args[1];
+      if (pathNode.type !== "Literal") {
+        throw new Error("PostgreSQL JSON_SET currently supports literal paths only");
+      }
+      const pathArray = this.formatJsonbPathArray(pathNode);
+      return `jsonb_set(${compiledArgs[0]}, ${pathArray}, ${compiledArgs[2]}::jsonb, true)`;
+    });
+  }
+  formatJsonbPathArray(pathNode) {
+    const rawPath = String(pathNode.value ?? "");
+    if (!rawPath.startsWith("$")) {
+      throw new Error('PostgreSQL JSON_SET paths must start with "$"');
+    }
+    const trimmed = rawPath === "$" ? "" : rawPath.startsWith("$.") ? rawPath.slice(2) : rawPath.slice(1);
+    if (!trimmed) {
+      throw new Error("PostgreSQL JSON_SET requires a non-root path");
+    }
+    if (trimmed.includes("[") || trimmed.includes("]")) {
+      throw new Error("PostgreSQL JSON_SET currently only supports simple dot-separated paths");
+    }
+    const segments = trimmed.split(".").map((segment) => segment.replace(/^['"]?/, "").replace(/['"]?$/, "").trim()).filter(Boolean);
+    if (!segments.length) {
+      throw new Error("PostgreSQL JSON_SET requires at least one path segment");
+    }
+    const escapedSegments = segments.map((segment) => `'${segment.replace(/'/g, "''")}'`);
+    return `ARRAY[${escapedSegments.join(", ")}]`;
+  }
+};
+
+// src/core/dialect/postgres/table-functions.ts
+var PostgresTableFunctionStrategy = class extends StandardTableFunctionStrategy {
+  constructor() {
+    super();
+    this.registerOverrides();
+  }
+  registerOverrides() {
+    this.add("ARRAY_UNNEST", ({ node, compiledArgs, quoteIdentifier }) => {
+      const lateral = node.lateral ?? true;
+      const withOrd = node.withOrdinality ?? false;
+      const base = `unnest(${compiledArgs.join(", ")})${withOrd ? " WITH ORDINALITY" : ""}`;
+      if (node.columnAliases?.length && !node.alias) {
+        throw new Error("tvf(ARRAY_UNNEST) with columnAliases requires an alias.");
+      }
+      const alias = node.alias ? ` AS ${quoteIdentifier(node.alias)}` : "";
+      const cols = node.columnAliases?.length ? `(${node.columnAliases.map(quoteIdentifier).join(", ")})` : "";
+      return `${lateral ? "LATERAL " : ""}${base}${alias}${cols}`;
+    });
   }
 };
 
@@ -2114,8 +2543,20 @@ var PostgresDialect = class extends SqlDialectBase {
    * Creates a new PostgresDialect instance
    */
   constructor() {
-    super(new PostgresFunctionStrategy());
+    super(new PostgresFunctionStrategy(), new PostgresTableFunctionStrategy());
     this.dialect = "postgres";
+    this.registerExpressionCompiler("BitwiseExpression", (node, ctx) => {
+      const left2 = this.compileOperand(node.left, ctx);
+      const right2 = this.compileOperand(node.right, ctx);
+      const op = node.operator === "^" ? "#" : node.operator;
+      return `${left2} ${op} ${right2}`;
+    });
+    this.registerOperandCompiler("BitwiseExpression", (node, ctx) => {
+      const left2 = this.compileOperand(node.left, ctx);
+      const right2 = this.compileOperand(node.right, ctx);
+      const op = node.operator === "^" ? "#" : node.operator;
+      return `(${left2} ${op} ${right2})`;
+    });
   }
   /**
    * Quotes an identifier using PostgreSQL double-quote syntax
@@ -2224,6 +2665,14 @@ var MysqlFunctionStrategy = class extends StandardFunctionStrategy {
       }
       return `DATE(${date})`;
     });
+    this.add("HOUR", ({ compiledArgs }) => `HOUR(${compiledArgs[0]})`);
+    this.add("MINUTE", ({ compiledArgs }) => `MINUTE(${compiledArgs[0]})`);
+    this.add("SECOND", ({ compiledArgs }) => `SECOND(${compiledArgs[0]})`);
+    this.add("QUARTER", ({ compiledArgs }) => `QUARTER(${compiledArgs[0]})`);
+    this.add("ARRAY_APPEND", ({ compiledArgs }) => {
+      if (compiledArgs.length !== 2) throw new Error("ARRAY_APPEND expects 2 arguments (array, value)");
+      return `JSON_ARRAY_APPEND(${compiledArgs[0]}, '$', ${compiledArgs[1]})`;
+    });
   }
 };
 
@@ -2356,6 +2805,30 @@ var SqliteFunctionStrategy = class extends StandardFunctionStrategy {
       const separator = ctx.compileOperand(separatorOperand);
       return `GROUP_CONCAT(${arg}, ${separator})`;
     });
+    this.add("HOUR", ({ compiledArgs }) => `CAST(strftime('%H', ${compiledArgs[0]}) AS INTEGER)`);
+    this.add("MINUTE", ({ compiledArgs }) => `CAST(strftime('%M', ${compiledArgs[0]}) AS INTEGER)`);
+    this.add("SECOND", ({ compiledArgs }) => `CAST(strftime('%S', ${compiledArgs[0]}) AS INTEGER)`);
+    this.add("QUARTER", ({ compiledArgs }) => `((CAST(strftime('%m', ${compiledArgs[0]}) AS INTEGER) + 2) / 3)`);
+    this.add("JSON_LENGTH", ({ compiledArgs }) => {
+      if (compiledArgs.length === 0 || compiledArgs.length > 2) {
+        throw new Error("JSON_LENGTH expects 1 or 2 arguments on SQLite");
+      }
+      return `json_array_length(${compiledArgs.join(", ")})`;
+    });
+    this.add("JSON_ARRAYAGG", ({ compiledArgs }) => {
+      if (compiledArgs.length !== 1) {
+        throw new Error("JSON_ARRAYAGG expects 1 argument on SQLite");
+      }
+      return `json_group_array(${compiledArgs[0]})`;
+    });
+    this.add("JSON_CONTAINS", () => {
+      throw new Error("JSON_CONTAINS is not supported on SQLite");
+    });
+    this.add("ARRAY_APPEND", ({ compiledArgs }) => {
+      if (compiledArgs.length !== 2) throw new Error("ARRAY_APPEND expects 2 arguments (array, value)");
+      return `json_array_append(${compiledArgs[0]}, '$', ${compiledArgs[1]})`;
+    });
+    this.add("CHR", ({ compiledArgs }) => `CHAR(${compiledArgs[0]})`);
   }
 };
 
@@ -2367,6 +2840,22 @@ var SqliteDialect = class extends SqlDialectBase {
   constructor() {
     super(new SqliteFunctionStrategy());
     this.dialect = "sqlite";
+    this.registerExpressionCompiler("BitwiseExpression", (node, ctx) => {
+      const left2 = this.compileOperand(node.left, ctx);
+      const right2 = this.compileOperand(node.right, ctx);
+      if (node.operator === "^") {
+        return `(${left2} | ${right2}) & ~(${left2} & ${right2})`;
+      }
+      return `${left2} ${node.operator} ${right2}`;
+    });
+    this.registerOperandCompiler("BitwiseExpression", (node, ctx) => {
+      const left2 = this.compileOperand(node.left, ctx);
+      const right2 = this.compileOperand(node.right, ctx);
+      if (node.operator === "^") {
+        return `((${left2} | ${right2}) & ~(${left2} & ${right2}))`;
+      }
+      return `(${left2} ${node.operator} ${right2})`;
+    });
   }
   /**
    * Quotes an identifier using SQLite double-quote syntax
@@ -2491,6 +2980,33 @@ var MssqlFunctionStrategy = class extends StandardFunctionStrategy {
       const withinGroup = orderClause ? ` WITHIN GROUP (${orderClause})` : "";
       return `STRING_AGG(${arg}, ${separator})${withinGroup}`;
     });
+    this.add("LENGTH", ({ compiledArgs }) => `LEN(${compiledArgs[0]})`);
+    this.add("CHAR_LENGTH", ({ compiledArgs }) => `LEN(${compiledArgs[0]})`);
+    this.add("CHARACTER_LENGTH", ({ compiledArgs }) => `LEN(${compiledArgs[0]})`);
+    this.add("POSITION", ({ compiledArgs }) => `CHARINDEX(${compiledArgs[0]}, ${compiledArgs[1]})`);
+    this.add("LOCATE", ({ compiledArgs }) => compiledArgs.length === 3 ? `CHARINDEX(${compiledArgs[0]}, ${compiledArgs[1]}, ${compiledArgs[2]})` : `CHARINDEX(${compiledArgs[0]}, ${compiledArgs[1]})`);
+    this.add("INSTR", ({ compiledArgs }) => `CHARINDEX(${compiledArgs[1]}, ${compiledArgs[0]})`);
+    this.add("CHR", ({ compiledArgs }) => `CHAR(${compiledArgs[0]})`);
+    this.add("HOUR", ({ compiledArgs }) => `DATEPART(hour, ${compiledArgs[0]})`);
+    this.add("MINUTE", ({ compiledArgs }) => `DATEPART(minute, ${compiledArgs[0]})`);
+    this.add("SECOND", ({ compiledArgs }) => `DATEPART(second, ${compiledArgs[0]})`);
+    this.add("QUARTER", ({ compiledArgs }) => `DATEPART(quarter, ${compiledArgs[0]})`);
+    this.add("JSON_SET", ({ compiledArgs }) => {
+      if (compiledArgs.length !== 3) throw new Error("JSON_SET expects 3 arguments on SQL Server");
+      return `JSON_MODIFY(${compiledArgs[0]}, ${compiledArgs[1]}, ${compiledArgs[2]})`;
+    });
+    this.add("JSON_LENGTH", () => {
+      throw new Error("JSON_LENGTH is not supported on SQL Server");
+    });
+    this.add("JSON_ARRAYAGG", () => {
+      throw new Error("JSON_ARRAYAGG is not supported on SQL Server");
+    });
+    this.add("JSON_CONTAINS", () => {
+      throw new Error("JSON_CONTAINS is not supported on SQL Server");
+    });
+    this.add("ARRAY_APPEND", () => {
+      throw new Error("ARRAY_APPEND is not supported on SQL Server");
+    });
   }
 };
 
@@ -4288,6 +4804,17 @@ var hideInternal2 = (obj, keys) => {
   }
 };
 var DefaultHasOneReference = class {
+  /**
+   * @param ctx The entity context for tracking changes.
+   * @param meta Metadata for the parent entity.
+   * @param root The parent entity instance.
+   * @param relationName The name of the relation.
+   * @param relation Relation definition.
+   * @param rootTable Table definition of the parent entity.
+   * @param loader Function to load the child entity.
+   * @param createEntity Function to create entity instances from rows.
+   * @param localKey The local key on the parent entity used for the relation.
+   */
   constructor(ctx, meta, root, relationName, relation, rootTable, loader, createEntity, localKey) {
     this.ctx = ctx;
     this.meta = meta;
@@ -4405,6 +4932,17 @@ var hideInternal3 = (obj, keys) => {
   }
 };
 var DefaultBelongsToReference = class {
+  /**
+   * @param ctx The entity context for tracking changes.
+   * @param meta Metadata for the child entity.
+   * @param root The child entity instance (carrying the foreign key).
+   * @param relationName The name of the relation.
+   * @param relation Relation definition.
+   * @param rootTable Table definition of the child entity.
+   * @param loader Function to load the parent entity.
+   * @param createEntity Function to create entity instances from rows.
+   * @param targetKey The primary key of the target (parent) table.
+   */
   constructor(ctx, meta, root, relationName, relation, rootTable, loader, createEntity, targetKey) {
     this.ctx = ctx;
     this.meta = meta;
@@ -4496,6 +5034,17 @@ var hideInternal4 = (obj, keys) => {
   }
 };
 var DefaultManyToManyCollection = class {
+  /**
+   * @param ctx The entity context for tracking changes.
+   * @param meta Metadata for the root entity.
+   * @param root The root entity instance.
+   * @param relationName The name of the relation.
+   * @param relation Relation definition.
+   * @param rootTable Table definition of the root entity.
+   * @param loader Function to load the collection items.
+   * @param createEntity Function to create entity instances from rows.
+   * @param localKey The local key used for joining.
+   */
   constructor(ctx, meta, root, relationName, relation, rootTable, loader, createEntity, localKey) {
     this.ctx = ctx;
     this.meta = meta;
@@ -4511,6 +5060,10 @@ var DefaultManyToManyCollection = class {
     hideInternal4(this, ["ctx", "meta", "root", "relationName", "relation", "rootTable", "loader", "createEntity", "localKey"]);
     this.hydrateFromCache();
   }
+  /**
+   * Loads the collection items if not already loaded.
+   * @returns A promise that resolves to the array of target entities.
+   */
   async load() {
     if (this.loaded) return this.items;
     const map = await this.loader();
@@ -4526,9 +5079,18 @@ var DefaultManyToManyCollection = class {
     this.loaded = true;
     return this.items;
   }
+  /**
+   * Returns the currently loaded items.
+   * @returns Array of target entities.
+   */
   getItems() {
     return this.items;
   }
+  /**
+   * Attaches an entity to the collection.
+   * Registers an 'attach' change in the entity context.
+   * @param target Entity instance or its primary key value.
+   */
   attach(target) {
     const entity = this.ensureEntity(target);
     const id = this.extractId(entity);
@@ -4548,6 +5110,11 @@ var DefaultManyToManyCollection = class {
       { kind: "attach", entity }
     );
   }
+  /**
+   * Detaches an entity from the collection.
+   * Registers a 'detach' change in the entity context.
+   * @param target Entity instance or its primary key value.
+   */
   detach(target) {
     const id = typeof target === "number" || typeof target === "string" ? target : this.extractId(target);
     if (id == null) return;
@@ -4563,6 +5130,11 @@ var DefaultManyToManyCollection = class {
       { kind: "detach", entity: existing }
     );
   }
+  /**
+   * Syncs the collection with a list of IDs.
+   * Attaches missing IDs and detaches IDs not in the list.
+   * @param ids Array of primary key values to sync with.
+   */
   async syncByIds(ids) {
     await this.load();
     const normalized = new Set(ids.map((id) => toKey5(id)));
@@ -7791,6 +8363,14 @@ var repeat = (value, count2) => fn("REPEAT", [value, count2]);
 var lpad = (value, len, pad) => fn("LPAD", [value, len, pad]);
 var rpad = (value, len, pad) => fn("RPAD", [value, len, pad]);
 var space = (count2) => fn("SPACE", [count2]);
+var reverse = (value) => fn("REVERSE", [value]);
+var initcap = (value) => fn("INITCAP", [value]);
+var md5 = (value) => fn("MD5", [value]);
+var sha1 = (value) => fn("SHA1", [value]);
+var sha2 = (value, bits) => fn("SHA2", [value, bits]);
+var bitLength = (value) => fn("BIT_LENGTH", [value]);
+var octetLength = (value) => fn("OCTET_LENGTH", [value]);
+var chr = (code) => fn("CHR", [code]);
 
 // src/core/ddl/introspect/functions/mssql.ts
 var isColumnReference = (value) => typeof value === "object" && value !== null && !("type" in value) && "name" in value && typeof value.name === "string";
@@ -8349,6 +8929,8 @@ var sqrt = (value) => fn3("SQRT", [value]);
 var tan = (value) => fn3("TAN", [value]);
 var trunc = (value, decimals) => decimals === void 0 ? fn3("TRUNC", [value]) : fn3("TRUNC", [value, decimals]);
 var truncate = (value, decimals) => fn3("TRUNCATE", [value, decimals]);
+var log2 = (value) => fn3("LOG2", [value]);
+var cbrt = (value) => fn3("CBRT", [value]);
 
 // src/core/functions/datetime.ts
 var isColumnDef3 = (val) => !!val && typeof val === "object" && "type" in val && "name" in val;
@@ -8360,12 +8942,15 @@ var toOperand4 = (input) => {
 var fn4 = (key, args) => ({
   type: "Function",
   name: key,
+  fn: key,
   args: args.map(toOperand4)
 });
 var now = () => fn4("NOW", []);
 var currentDate = () => fn4("CURRENT_DATE", []);
 var currentTime = () => fn4("CURRENT_TIME", []);
 var utcNow = () => fn4("UTC_NOW", []);
+var localTime = () => fn4("LOCALTIME", []);
+var localTimestamp = () => fn4("LOCALTIMESTAMP", []);
 var extract = (part, date) => fn4("EXTRACT", [part, date]);
 var year = (date) => fn4("YEAR", [date]);
 var month = (date) => fn4("MONTH", [date]);
@@ -8380,6 +8965,72 @@ var endOfMonth = (date) => fn4("END_OF_MONTH", [date]);
 var dayOfWeek = (date) => fn4("DAY_OF_WEEK", [date]);
 var weekOfYear = (date) => fn4("WEEK_OF_YEAR", [date]);
 var dateTrunc = (part, date) => fn4("DATE_TRUNC", [part, date]);
+var age = (timestamp, baseTimestamp) => baseTimestamp === void 0 ? fn4("AGE", [timestamp]) : fn4("AGE", [timestamp, baseTimestamp]);
+var hour = (date) => fn4("HOUR", [date]);
+var minute = (date) => fn4("MINUTE", [date]);
+var second = (date) => fn4("SECOND", [date]);
+var quarter = (date) => fn4("QUARTER", [date]);
+
+// src/core/functions/control-flow.ts
+var isColumnDef4 = (val) => !!val && typeof val === "object" && "type" in val && "name" in val;
+var toOperand5 = (input) => {
+  if (isOperandNode(input)) return input;
+  if (isColumnDef4(input)) return columnOperand(input);
+  return valueToOperand(input);
+};
+var fn5 = (key, args) => ({
+  type: "Function",
+  name: key,
+  fn: key,
+  args: args.map(toOperand5)
+});
+var coalesce = (...args) => {
+  if (args.length < 2) throw new Error("coalesce() expects at least 2 arguments");
+  return fn5("COALESCE", args);
+};
+var nullif = (val1, val2) => fn5("NULLIF", [val1, val2]);
+var greatest = (...args) => {
+  if (args.length < 2) throw new Error("greatest() expects at least 2 arguments");
+  return fn5("GREATEST", args);
+};
+var least = (...args) => {
+  if (args.length < 2) throw new Error("least() expects at least 2 arguments");
+  return fn5("LEAST", args);
+};
+var ifNull = (val, defaultValue) => coalesce(val, defaultValue);
+
+// src/core/functions/json.ts
+var isColumnDef5 = (val) => !!val && typeof val === "object" && "type" in val && "name" in val;
+var toOperand6 = (input) => {
+  if (isOperandNode(input)) return input;
+  if (isColumnDef5(input)) return columnOperand(input);
+  return valueToOperand(input);
+};
+var fn6 = (key, args) => ({
+  type: "Function",
+  name: key,
+  fn: key,
+  args: args.map(toOperand6)
+});
+var jsonLength = (target, path) => path === void 0 ? fn6("JSON_LENGTH", [target]) : fn6("JSON_LENGTH", [target, path]);
+var jsonSet = (target, path, value) => fn6("JSON_SET", [target, path, value]);
+var jsonArrayAgg = (value) => fn6("JSON_ARRAYAGG", [value]);
+var jsonContains = (target, candidate, path) => path === void 0 ? fn6("JSON_CONTAINS", [target, candidate]) : fn6("JSON_CONTAINS", [target, candidate, path]);
+
+// src/core/functions/array.ts
+var isColumnDef6 = (val) => !!val && typeof val === "object" && "type" in val && "name" in val;
+var toOperand7 = (input) => {
+  if (isOperandNode(input)) return input;
+  if (isColumnDef6(input)) return columnOperand(input);
+  return valueToOperand(input);
+};
+var fn7 = (key, args) => ({
+  type: "Function",
+  name: key,
+  fn: key,
+  args: args.map(toOperand7)
+});
+var arrayAppend = (array, value) => fn7("ARRAY_APPEND", [array, value]);
 
 // src/orm/als.ts
 var AsyncLocalStorage = class {
@@ -8459,7 +9110,7 @@ var DefaultNamingStrategy = class {
    * @returns Capitalized table name (handles schema-qualified names)
    */
   tableToSymbol(table) {
-    const tableName = typeof table === "string" ? table : table.type === "DerivedTable" ? table.alias : table.name;
+    const tableName = typeof table === "string" ? table : table.type === "DerivedTable" ? table.alias : table.type === "FunctionTable" ? table.alias ?? table.name : table.name;
     if (tableName.includes(".")) {
       return tableName.split(".").map((part) => this.capitalize(part)).join("");
     }
@@ -8615,6 +9266,7 @@ var TypeScriptGenerator = class {
       case "CaseExpression":
       case "WindowFunction":
       case "Cast":
+      case "Collate":
         return this.printOperand(term);
       default:
         return this.printExpression(term);
@@ -8677,6 +9329,9 @@ var TypeScriptGenerator = class {
   visitCast(node) {
     return this.printCastOperand(node);
   }
+  visitCollate(node) {
+    return this.printCollateOperand(node);
+  }
   visitAliasRef(node) {
     return `aliasRef('${node.name}')`;
   }
@@ -8688,12 +9343,12 @@ var TypeScriptGenerator = class {
   printBinaryExpression(binary) {
     const left2 = this.printOperand(binary.left);
     const right2 = this.printOperand(binary.right);
-    const fn5 = this.mapOp(binary.operator);
+    const fn8 = this.mapOp(binary.operator);
     const args = [left2, right2];
     if (binary.escape) {
       args.push(this.printOperand(binary.escape));
     }
-    return `${fn5}(${args.join(", ")})`;
+    return `${fn8}(${args.join(", ")})`;
   }
   /**
    * Prints a logical expression to TypeScript code
@@ -8722,13 +9377,13 @@ var TypeScriptGenerator = class {
    */
   printInExpression(inExpr) {
     const left2 = this.printOperand(inExpr.left);
-    const fn5 = this.mapOp(inExpr.operator);
+    const fn8 = this.mapOp(inExpr.operator);
     if (Array.isArray(inExpr.right)) {
       const values = inExpr.right.map((v) => this.printOperand(v)).join(", ");
-      return `${fn5}(${left2}, [${values}])`;
+      return `${fn8}(${left2}, [${values}])`;
     }
     const subquery = this.inlineChain(this.buildSelectLines(inExpr.right.query));
-    return `${fn5}(${left2}, (${subquery}))`;
+    return `${fn8}(${left2}, (${subquery}))`;
   }
   /**
    * Prints a null expression to TypeScript code
@@ -8737,8 +9392,8 @@ var TypeScriptGenerator = class {
    */
   printNullExpression(nullExpr) {
     const left2 = this.printOperand(nullExpr.left);
-    const fn5 = this.mapOp(nullExpr.operator);
-    return `${fn5}(${left2})`;
+    const fn8 = this.mapOp(nullExpr.operator);
+    return `${fn8}(${left2})`;
   }
   /**
    * Prints a BETWEEN expression to TypeScript code
@@ -8782,9 +9437,9 @@ var TypeScriptGenerator = class {
    * @param fn - Function node
    * @returns TypeScript code representation
    */
-  printFunctionOperand(fn5) {
-    const args = fn5.args.map((a) => this.printOperand(a)).join(", ");
-    return `${fn5.name.toLowerCase()}(${args})`;
+  printFunctionOperand(fn8) {
+    const args = fn8.args.map((a) => this.printOperand(a)).join(", ");
+    return `${fn8.name.toLowerCase()}(${args})`;
   }
   /**
    * Prints a JSON path operand to TypeScript code
@@ -8848,6 +9503,9 @@ var TypeScriptGenerator = class {
     const typeLiteral = node.castType.replace(/'/g, "\\'");
     return `cast(${this.printOperand(node.expression)}, '${typeLiteral}')`;
   }
+  printCollateOperand(node) {
+    return `collate(${this.printOperand(node.expression)}, '${node.collation}')`;
+  }
   /**
    * Converts method chain lines to inline format
    * @param lines - Method chain lines
@@ -8878,10 +9536,20 @@ var IdentityMap = class {
   get bucketsMap() {
     return this.buckets;
   }
+  /**
+   * Retrieves an entity from the identity map if it exists.
+   * @param table The table definition of the entity.
+   * @param pk The primary key value.
+   * @returns The entity instance if found, undefined otherwise.
+   */
   getEntity(table, pk) {
     const bucket = this.buckets.get(table.name);
     return bucket?.get(this.toIdentityKey(pk))?.entity;
   }
+  /**
+   * Registers a tracked entity in the identity map.
+   * @param tracked The tracked entity metadata and instance.
+   */
   register(tracked) {
     if (tracked.pk == null) return;
     const bucket = this.buckets.get(tracked.table.name) ?? /* @__PURE__ */ new Map();
@@ -8893,6 +9561,11 @@ var IdentityMap = class {
     const bucket = this.buckets.get(tracked.table.name);
     bucket?.delete(this.toIdentityKey(tracked.pk));
   }
+  /**
+   * Returns all tracked entities for a specific table.
+   * @param table The table definition.
+   * @returns Array of tracked entities.
+   */
   getEntitiesForTable(table) {
     const bucket = this.buckets.get(table.name);
     return bucket ? Array.from(bucket.values()) : [];
@@ -10017,15 +10690,15 @@ var OrmSession = class {
    * @returns The result of the function
    * @throws If the transaction fails
    */
-  async transaction(fn5) {
+  async transaction(fn8) {
     if (!this.executor.capabilities.transactions) {
-      const result = await fn5(this);
+      const result = await fn8(this);
       await this.commit();
       return result;
     }
     await this.executor.beginTransaction();
     try {
-      const result = await fn5(this);
+      const result = await fn8(this);
       await this.flushWithHooks();
       await this.executor.commitTransaction();
       await this.domainEvents.dispatch(this.unitOfWork.getTracked(), this);
@@ -10128,11 +10801,11 @@ var Orm = class {
    * @returns The result of the function
    * @throws If the transaction fails
    */
-  async transaction(fn5) {
+  async transaction(fn8) {
     const executor = this.executorFactory.createTransactionalExecutor();
     const session = new OrmSession({ orm: this, executor });
     try {
-      return await session.transaction(() => fn5(session));
+      return await session.transaction(() => fn8(session));
     } finally {
       await session.dispose();
     }
@@ -10958,8 +11631,10 @@ function createPooledExecutorFactory(opts) {
   acos,
   add,
   addDomainEvent,
+  age,
   aliasRef,
   and,
+  arrayAppend,
   ascii,
   asin,
   atan,
@@ -10968,16 +11643,24 @@ function createPooledExecutorFactory(opts) {
   belongsTo,
   belongsToMany,
   between,
+  bitAnd,
+  bitLength,
+  bitOr,
+  bitXor,
   bootstrapEntities,
   caseWhen,
   cast,
+  cbrt,
   ceil,
   ceiling,
   char,
   charLength,
+  chr,
   clearExpressionDispatchers,
   clearOperandDispatchers,
+  coalesce,
   col,
+  collate,
   columnOperand,
   concat,
   concatWs,
@@ -11029,18 +11712,23 @@ function createPooledExecutorFactory(opts) {
   getDecoratorMetadata,
   getSchemaIntrospector,
   getTableDefFromEntity,
+  greatest,
   groupConcat,
   gt,
   gte,
   hasMany,
   hasOne,
+  hour,
   hydrateRows,
+  ifNull,
   inList,
   inSubquery,
+  initcap,
   instr,
   introspectSchema,
   isCaseExpressionNode,
   isCastExpressionNode,
+  isCollateExpressionNode,
   isExpressionSelectionNode,
   isFunctionNode,
   isNotNull,
@@ -11048,11 +11736,16 @@ function createPooledExecutorFactory(opts) {
   isOperandNode,
   isValueOperandInput,
   isWindowFunctionNode,
+  jsonArrayAgg,
+  jsonContains,
+  jsonLength,
   jsonPath,
+  jsonSet,
   jsonify,
   lag,
   lastValue,
   lead,
+  least,
   left,
   length,
   like,
@@ -11061,9 +11754,12 @@ function createPooledExecutorFactory(opts) {
   loadBelongsToRelation,
   loadHasManyRelation,
   loadHasOneRelation,
+  localTime,
+  localTimestamp,
   locate,
   log,
   log10,
+  log2,
   logBase,
   lower,
   lpad,
@@ -11071,7 +11767,9 @@ function createPooledExecutorFactory(opts) {
   lte,
   ltrim,
   max,
+  md5,
   min,
+  minute,
   mod,
   month,
   mul,
@@ -11084,12 +11782,15 @@ function createPooledExecutorFactory(opts) {
   notLike,
   now,
   ntile,
+  nullif,
+  octetLength,
   or,
   outerRef,
   pi,
   position,
   pow,
   power,
+  quarter,
   radians,
   rand,
   random,
@@ -11101,18 +11802,25 @@ function createPooledExecutorFactory(opts) {
   renderTypeWithArgs,
   repeat,
   replace,
+  reverse,
   right,
   round,
   rowNumber,
   rowsToQueryResult,
   rpad,
   rtrim,
+  second,
   sel,
   selectFromEntity,
+  sha1,
+  sha2,
+  shiftLeft,
+  shiftRight,
   sign,
   sin,
   space,
   sqrt,
+  stddev,
   sub,
   substr,
   sum,
@@ -11128,6 +11836,7 @@ function createPooledExecutorFactory(opts) {
   upper,
   utcNow,
   valueToOperand,
+  variance,
   visitExpression,
   visitOperand,
   weekOfYear,