metal-orm 1.0.56 → 1.0.58

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,
@@ -213,22 +241,30 @@ __export(index_exports, {
   registerExpressionDispatcher: () => registerExpressionDispatcher,
   registerOperandDispatcher: () => registerOperandDispatcher,
   registerSchemaIntrospector: () => registerSchemaIntrospector,
+  relationLoaderCache: () => relationLoaderCache,
   renderColumnDefinition: () => renderColumnDefinition,
   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 +280,7 @@ __export(index_exports, {
   upper: () => upper,
   utcNow: () => utcNow,
   valueToOperand: () => valueToOperand,
+  variance: () => variance,
   visitExpression: () => visitExpression,
   visitOperand: () => visitOperand,
   weekOfYear: () => weekOfYear,
@@ -586,7 +623,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 +635,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 +760,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 +799,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 +949,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 +1024,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 +1064,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 +1137,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 +1475,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 +1483,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 +1491,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 +1499,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 +1690,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 +1703,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 +1725,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 +1826,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 +1900,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 +1941,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 +1957,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 +1970,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 +1987,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 +1997,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 +2007,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 +2019,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 +2289,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 +2465,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 +2544,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 +2666,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 +2806,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 +2841,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 +2981,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");
+    });
   }
 };
 
@@ -3595,20 +4112,21 @@ var RelationProjectionHelper = class {
 var assertNever = (value) => {
   throw new Error(`Unhandled relation type: ${JSON.stringify(value)}`);
 };
-var baseRelationCondition = (root, relation, rootAlias) => {
+var baseRelationCondition = (root, relation, rootAlias, targetTableName) => {
   const rootTable = rootAlias || root.name;
+  const targetTable = targetTableName ?? relation.target.name;
   const defaultLocalKey = relation.type === RelationKinds.HasMany || relation.type === RelationKinds.HasOne ? findPrimaryKey(root) : findPrimaryKey(relation.target);
   const localKey = relation.localKey || defaultLocalKey;
   switch (relation.type) {
     case RelationKinds.HasMany:
     case RelationKinds.HasOne:
       return eq(
-        { type: "Column", table: relation.target.name, name: relation.foreignKey },
+        { type: "Column", table: targetTable, name: relation.foreignKey },
         { type: "Column", table: rootTable, name: localKey }
       );
     case RelationKinds.BelongsTo:
       return eq(
-        { type: "Column", table: relation.target.name, name: localKey },
+        { type: "Column", table: targetTable, name: localKey },
         { type: "Column", table: rootTable, name: relation.foreignKey }
       );
     case RelationKinds.BelongsToMany:
@@ -3617,7 +4135,7 @@ var baseRelationCondition = (root, relation, rootAlias) => {
       return assertNever(relation);
   }
 };
-var buildBelongsToManyJoins = (root, relationName, relation, joinKind, extra, rootAlias) => {
+var buildBelongsToManyJoins = (root, relationName, relation, joinKind, extra, rootAlias, targetTable, targetTableName) => {
   const rootKey = relation.localKey || findPrimaryKey(root);
   const targetKey = relation.targetKey || findPrimaryKey(relation.target);
   const rootTable = rootAlias || root.name;
@@ -3630,8 +4148,14 @@ var buildBelongsToManyJoins = (root, relationName, relation, joinKind, extra, ro
     { type: "Table", name: relation.pivotTable.name, schema: relation.pivotTable.schema },
     pivotCondition
   );
+  const targetSource = targetTable ?? {
+    type: "Table",
+    name: relation.target.name,
+    schema: relation.target.schema
+  };
+  const effectiveTargetName = targetTableName ?? relation.target.name;
   let targetCondition = eq(
-    { type: "Column", table: relation.target.name, name: targetKey },
+    { type: "Column", table: effectiveTargetName, name: targetKey },
     { type: "Column", table: relation.pivotTable.name, name: relation.pivotForeignKeyToTarget }
   );
   if (extra) {
@@ -3639,24 +4163,25 @@ var buildBelongsToManyJoins = (root, relationName, relation, joinKind, extra, ro
   }
   const targetJoin = createJoinNode(
     joinKind,
-    { type: "Table", name: relation.target.name, schema: relation.target.schema },
+    targetSource,
     targetCondition,
     relationName
   );
   return [pivotJoin, targetJoin];
 };
-var buildRelationJoinCondition = (root, relation, extra, rootAlias) => {
-  const base = baseRelationCondition(root, relation, rootAlias);
+var buildRelationJoinCondition = (root, relation, extra, rootAlias, targetTableName) => {
+  const base = baseRelationCondition(root, relation, rootAlias, targetTableName);
   return extra ? and(base, extra) : base;
 };
-var buildRelationCorrelation = (root, relation, rootAlias) => {
-  return baseRelationCondition(root, relation, rootAlias);
+var buildRelationCorrelation = (root, relation, rootAlias, targetTableName) => {
+  return baseRelationCondition(root, relation, rootAlias, targetTableName);
 };
 
 // src/core/ast/join-metadata.ts
 var getJoinRelationName = (join) => join.meta?.relationName;
 
 // src/query-builder/relation-service.ts
+var hasRelationForeignKey = (relation) => relation.type !== RelationKinds.BelongsToMany;
 var RelationService = class {
   /**
    * Creates a new RelationService instance
@@ -3681,8 +4206,8 @@ var RelationService = class {
    * @param extraCondition - Additional join condition
    * @returns Relation result with updated state and hydration
    */
-  joinRelation(relationName, joinKind, extraCondition) {
-    const nextState = this.withJoin(this.state, relationName, joinKind, extraCondition);
+  joinRelation(relationName, joinKind, extraCondition, tableSource) {
+    const nextState = this.withJoin(this.state, relationName, joinKind, extraCondition, tableSource);
     return { state: nextState, hydration: this.hydration };
   }
   /**
@@ -3711,14 +4236,58 @@ var RelationService = class {
     const relation = this.getRelation(relationName);
     const aliasPrefix = options?.aliasPrefix ?? relationName;
     const alreadyJoined = state.ast.joins.some((j) => getJoinRelationName(j) === relationName);
+    const { selfFilters, crossFilters } = this.splitFilterExpressions(
+      options?.filter,
+      /* @__PURE__ */ new Set([relation.target.name])
+    );
+    const canUseCte = !alreadyJoined && selfFilters.length > 0;
+    const joinFilters = [...crossFilters];
+    if (!canUseCte) {
+      joinFilters.push(...selfFilters);
+    }
+    const joinCondition = this.combineWithAnd(joinFilters);
+    let tableSourceOverride;
+    if (canUseCte) {
+      const cteInfo = this.createFilteredRelationCte(state, relationName, relation, selfFilters);
+      state = cteInfo.state;
+      tableSourceOverride = cteInfo.table;
+    }
     if (!alreadyJoined) {
-      const joined = this.joinRelation(relationName, options?.joinKind ?? JOIN_KINDS.LEFT, options?.filter);
-      state = joined.state;
+      state = this.withJoin(
+        state,
+        relationName,
+        options?.joinKind ?? JOIN_KINDS.LEFT,
+        joinCondition,
+        tableSourceOverride
+      );
     }
     const projectionResult = this.projectionHelper.ensureBaseProjection(state, hydration);
     state = projectionResult.state;
     hydration = projectionResult.hydration;
-    const targetColumns = options?.columns?.length ? options.columns : Object.keys(relation.target.columns);
+    if (hasRelationForeignKey(relation)) {
+      const fkColumn = this.table.columns[relation.foreignKey];
+      if (fkColumn) {
+        const hasForeignKeySelected = state.ast.columns.some((col2) => {
+          if (col2.type !== "Column") return false;
+          const node = col2;
+          const alias = node.alias ?? node.name;
+          return alias === relation.foreignKey;
+        });
+        if (!hasForeignKeySelected) {
+          const fkSelectionResult = this.selectColumns(state, hydration, {
+            [relation.foreignKey]: fkColumn
+          });
+          state = fkSelectionResult.state;
+          hydration = fkSelectionResult.hydration;
+        }
+      }
+    }
+    const requestedColumns = options?.columns?.length ? [...options.columns] : Object.keys(relation.target.columns);
+    const targetPrimaryKey = findPrimaryKey(relation.target);
+    if (!requestedColumns.includes(targetPrimaryKey)) {
+      requestedColumns.push(targetPrimaryKey);
+    }
+    const targetColumns = requestedColumns;
     const buildTypedSelection = (columns, prefix, keys, missingMsg) => {
       return keys.reduce((acc, key) => {
         const def = columns[key];
@@ -3802,27 +4371,42 @@ var RelationService = class {
    * @param extraCondition - Additional join condition
    * @returns Updated query state with join
    */
-  withJoin(state, relationName, joinKind, extraCondition) {
+  withJoin(state, relationName, joinKind, extraCondition, tableSource) {
     const relation = this.getRelation(relationName);
     const rootAlias = state.ast.from.type === "Table" ? state.ast.from.alias : void 0;
     if (relation.type === RelationKinds.BelongsToMany) {
+      const targetTableSource = tableSource ?? {
+        type: "Table",
+        name: relation.target.name,
+        schema: relation.target.schema
+      };
+      const targetName2 = this.resolveTargetTableName(targetTableSource, relation);
       const joins = buildBelongsToManyJoins(
         this.table,
         relationName,
         relation,
         joinKind,
         extraCondition,
-        rootAlias
+        rootAlias,
+        targetTableSource,
+        targetName2
       );
       return joins.reduce((current, join) => this.astService(current).withJoin(join), state);
     }
-    const condition = buildRelationJoinCondition(this.table, relation, extraCondition, rootAlias);
-    const joinNode = createJoinNode(
-      joinKind,
-      { type: "Table", name: relation.target.name, schema: relation.target.schema },
-      condition,
-      relationName
+    const targetTable = tableSource ?? {
+      type: "Table",
+      name: relation.target.name,
+      schema: relation.target.schema
+    };
+    const targetName = this.resolveTargetTableName(targetTable, relation);
+    const condition = buildRelationJoinCondition(
+      this.table,
+      relation,
+      extraCondition,
+      rootAlias,
+      targetName
     );
+    const joinNode = createJoinNode(joinKind, targetTable, condition, relationName);
     return this.astService(state).withJoin(joinNode);
   }
   /**
@@ -3839,6 +4423,198 @@ var RelationService = class {
       hydration: hydration.onColumnsSelected(nextState, addedColumns)
     };
   }
+  combineWithAnd(expressions) {
+    if (expressions.length === 0) return void 0;
+    if (expressions.length === 1) return expressions[0];
+    return {
+      type: "LogicalExpression",
+      operator: "AND",
+      operands: expressions
+    };
+  }
+  splitFilterExpressions(filter, allowedTables) {
+    const terms = this.flattenAnd(filter);
+    const selfFilters = [];
+    const crossFilters = [];
+    for (const term of terms) {
+      if (this.isExpressionSelfContained(term, allowedTables)) {
+        selfFilters.push(term);
+      } else {
+        crossFilters.push(term);
+      }
+    }
+    return { selfFilters, crossFilters };
+  }
+  flattenAnd(node) {
+    if (!node) return [];
+    if (node.type === "LogicalExpression" && node.operator === "AND") {
+      return node.operands.flatMap((operand) => this.flattenAnd(operand));
+    }
+    return [node];
+  }
+  isExpressionSelfContained(expr, allowedTables) {
+    const collector = this.collectReferencedTables(expr);
+    if (collector.hasSubquery) return false;
+    if (collector.tables.size === 0) return true;
+    for (const table of collector.tables) {
+      if (!allowedTables.has(table)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  collectReferencedTables(expr) {
+    const collector = {
+      tables: /* @__PURE__ */ new Set(),
+      hasSubquery: false
+    };
+    this.collectFromExpression(expr, collector);
+    return collector;
+  }
+  collectFromExpression(expr, collector) {
+    switch (expr.type) {
+      case "BinaryExpression":
+        this.collectFromOperand(expr.left, collector);
+        this.collectFromOperand(expr.right, collector);
+        break;
+      case "LogicalExpression":
+        expr.operands.forEach((operand) => this.collectFromExpression(operand, collector));
+        break;
+      case "NullExpression":
+        this.collectFromOperand(expr.left, collector);
+        break;
+      case "InExpression":
+        this.collectFromOperand(expr.left, collector);
+        if (Array.isArray(expr.right)) {
+          expr.right.forEach((value) => this.collectFromOperand(value, collector));
+        } else {
+          collector.hasSubquery = true;
+        }
+        break;
+      case "ExistsExpression":
+        collector.hasSubquery = true;
+        break;
+      case "BetweenExpression":
+        this.collectFromOperand(expr.left, collector);
+        this.collectFromOperand(expr.lower, collector);
+        this.collectFromOperand(expr.upper, collector);
+        break;
+      case "ArithmeticExpression":
+      case "BitwiseExpression":
+        this.collectFromOperand(expr.left, collector);
+        this.collectFromOperand(expr.right, collector);
+        break;
+      default:
+        break;
+    }
+  }
+  collectFromOperand(node, collector) {
+    switch (node.type) {
+      case "Column":
+        collector.tables.add(node.table);
+        break;
+      case "Function":
+        node.args.forEach((arg) => this.collectFromOperand(arg, collector));
+        if (node.separator) {
+          this.collectFromOperand(node.separator, collector);
+        }
+        if (node.orderBy) {
+          node.orderBy.forEach((order) => this.collectFromOrderingTerm(order.term, collector));
+        }
+        break;
+      case "JsonPath":
+        this.collectFromOperand(node.column, collector);
+        break;
+      case "ScalarSubquery":
+        collector.hasSubquery = true;
+        break;
+      case "CaseExpression":
+        node.conditions.forEach(({ when, then }) => {
+          this.collectFromExpression(when, collector);
+          this.collectFromOperand(then, collector);
+        });
+        if (node.else) {
+          this.collectFromOperand(node.else, collector);
+        }
+        break;
+      case "Cast":
+        this.collectFromOperand(node.expression, collector);
+        break;
+      case "WindowFunction":
+        node.args.forEach((arg) => this.collectFromOperand(arg, collector));
+        node.partitionBy?.forEach((part) => this.collectFromOperand(part, collector));
+        node.orderBy?.forEach((order) => this.collectFromOrderingTerm(order.term, collector));
+        break;
+      case "Collate":
+        this.collectFromOperand(node.expression, collector);
+        break;
+      case "ArithmeticExpression":
+      case "BitwiseExpression":
+        this.collectFromOperand(node.left, collector);
+        this.collectFromOperand(node.right, collector);
+        break;
+      case "Literal":
+      case "AliasRef":
+        break;
+      default:
+        break;
+    }
+  }
+  collectFromOrderingTerm(term, collector) {
+    if (isOperandNode(term)) {
+      this.collectFromOperand(term, collector);
+      return;
+    }
+    this.collectFromExpression(term, collector);
+  }
+  createFilteredRelationCte(state, relationName, relation, filters) {
+    const cteName = this.generateUniqueCteName(state, relationName);
+    const predicate = this.combineWithAnd(filters);
+    if (!predicate) {
+      throw new Error("Unable to build filter CTE without predicates.");
+    }
+    const columns = Object.keys(relation.target.columns).map((name) => ({
+      type: "Column",
+      table: relation.target.name,
+      name
+    }));
+    const cteQuery = {
+      type: "SelectQuery",
+      from: { type: "Table", name: relation.target.name, schema: relation.target.schema },
+      columns,
+      joins: [],
+      where: predicate
+    };
+    const nextState = this.astService(state).withCte(cteName, cteQuery);
+    const tableNode3 = {
+      type: "Table",
+      name: cteName,
+      alias: relation.target.name
+    };
+    return { state: nextState, table: tableNode3 };
+  }
+  generateUniqueCteName(state, relationName) {
+    const existing = new Set((state.ast.ctes ?? []).map((cte) => cte.name));
+    let candidate = `${relationName}__filtered`;
+    let suffix = 1;
+    while (existing.has(candidate)) {
+      candidate = `${relationName}__filtered_${suffix}`;
+      suffix += 1;
+    }
+    return candidate;
+  }
+  resolveTargetTableName(target, relation) {
+    if (target.type === "Table") {
+      return target.alias ?? target.name;
+    }
+    if (target.type === "DerivedTable") {
+      return target.alias;
+    }
+    if (target.type === "FunctionTable") {
+      return target.alias ?? relation.target.name;
+    }
+    return relation.target.name;
+  }
   /**
    * Gets a relation definition by name
    * @param relationName - Name of the relation
@@ -4189,6 +4965,18 @@ var DefaultHasManyCollection = class {
   getItems() {
     return this.items;
   }
+  /**
+   * Array-compatible length for testing frameworks.
+   */
+  get length() {
+    return this.items.length;
+  }
+  /**
+   * Enables iteration over the collection like an array.
+   */
+  [Symbol.iterator]() {
+    return this.items[Symbol.iterator]();
+  }
   /**
    * Adds a new child entity to the collection.
    * @param data - Partial data for the new entity
@@ -4288,6 +5076,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 +5204,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 +5306,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 +5332,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 +5351,30 @@ var DefaultManyToManyCollection = class {
     this.loaded = true;
     return this.items;
   }
+  /**
+   * Returns the currently loaded items.
+   * @returns Array of target entities.
+   */
   getItems() {
     return this.items;
   }
+  /**
+   * Array-compatible length for testing frameworks.
+   */
+  get length() {
+    return this.items.length;
+  }
+  /**
+   * Enables iteration over the collection like an array.
+   */
+  [Symbol.iterator]() {
+    return this.items[Symbol.iterator]();
+  }
+  /**
+   * 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 +5394,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 +5414,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)));
@@ -4621,10 +5477,27 @@ var DefaultManyToManyCollection = class {
 };
 
 // src/orm/lazy-batch.ts
-var selectAllColumns = (table) => Object.entries(table.columns).reduce((acc, [name, def]) => {
-  acc[name] = def;
-  return acc;
-}, {});
+var hasColumns = (columns) => Boolean(columns && columns.length > 0);
+var buildColumnSelection = (table, columns, missingMsg) => {
+  return columns.reduce((acc, column) => {
+    const def = table.columns[column];
+    if (!def) {
+      throw new Error(missingMsg(column));
+    }
+    acc[column] = def;
+    return acc;
+  }, {});
+};
+var filterRow = (row, columns) => {
+  const filtered = {};
+  for (const column of columns) {
+    if (column in row) {
+      filtered[column] = row[column];
+    }
+  }
+  return filtered;
+};
+var filterRows = (rows, columns) => rows.map((row) => filterRow(row, columns));
 var rowsFromResults = (results) => {
   const rows = [];
   for (const result of results) {
@@ -4656,9 +5529,12 @@ var collectKeysFromRoots = (roots, key) => {
   return collected;
 };
 var buildInListValues = (keys) => Array.from(keys);
-var fetchRowsForKeys = async (ctx, table, column, keys) => {
-  const qb = new SelectQueryBuilder(table).select(selectAllColumns(table));
-  qb.where(inList(column, buildInListValues(keys)));
+var fetchRowsForKeys = async (ctx, table, column, keys, selection, filter) => {
+  let qb = new SelectQueryBuilder(table).select(selection);
+  qb = qb.where(inList(column, buildInListValues(keys)));
+  if (filter) {
+    qb = qb.where(filter);
+  }
   return executeQuery(ctx, qb);
 };
 var groupRowsByMany = (rows, keyColumn) => {
@@ -4685,7 +5561,7 @@ var groupRowsByUnique = (rows, keyColumn) => {
   }
   return lookup;
 };
-var loadHasManyRelation = async (ctx, rootTable, _relationName, relation) => {
+var loadHasManyRelation = async (ctx, rootTable, relationName, relation, options) => {
   const localKey = relation.localKey || findPrimaryKey(rootTable);
   const roots = ctx.getEntitiesForTable(rootTable);
   const keys = collectKeysFromRoots(roots, localKey);
@@ -4694,10 +5570,30 @@ var loadHasManyRelation = async (ctx, rootTable, _relationName, relation) => {
   }
   const fkColumn = relation.target.columns[relation.foreignKey];
   if (!fkColumn) return /* @__PURE__ */ new Map();
-  const rows = await fetchRowsForKeys(ctx, relation.target, fkColumn, keys);
-  return groupRowsByMany(rows, relation.foreignKey);
+  const requestedColumns = hasColumns(options?.columns) ? [...options.columns] : void 0;
+  const targetPrimaryKey = findPrimaryKey(relation.target);
+  const selectedColumns = requestedColumns ? [...requestedColumns] : Object.keys(relation.target.columns);
+  if (!selectedColumns.includes(targetPrimaryKey)) {
+    selectedColumns.push(targetPrimaryKey);
+  }
+  const queryColumns = new Set(selectedColumns);
+  queryColumns.add(relation.foreignKey);
+  const selection = buildColumnSelection(
+    relation.target,
+    Array.from(queryColumns),
+    (column) => `Column '${column}' not found on relation '${relationName}'`
+  );
+  const rows = await fetchRowsForKeys(ctx, relation.target, fkColumn, keys, selection, options?.filter);
+  const grouped = groupRowsByMany(rows, relation.foreignKey);
+  if (!requestedColumns) return grouped;
+  const visibleColumns = new Set(selectedColumns);
+  const filtered = /* @__PURE__ */ new Map();
+  for (const [key, bucket] of grouped.entries()) {
+    filtered.set(key, filterRows(bucket, visibleColumns));
+  }
+  return filtered;
 };
-var loadHasOneRelation = async (ctx, rootTable, _relationName, relation) => {
+var loadHasOneRelation = async (ctx, rootTable, relationName, relation, options) => {
   const localKey = relation.localKey || findPrimaryKey(rootTable);
   const roots = ctx.getEntitiesForTable(rootTable);
   const keys = collectKeysFromRoots(roots, localKey);
@@ -4706,22 +5602,98 @@ var loadHasOneRelation = async (ctx, rootTable, _relationName, relation) => {
   }
   const fkColumn = relation.target.columns[relation.foreignKey];
   if (!fkColumn) return /* @__PURE__ */ new Map();
-  const rows = await fetchRowsForKeys(ctx, relation.target, fkColumn, keys);
-  return groupRowsByUnique(rows, relation.foreignKey);
+  const requestedColumns = hasColumns(options?.columns) ? [...options.columns] : void 0;
+  const targetPrimaryKey = findPrimaryKey(relation.target);
+  const selectedColumns = requestedColumns ? [...requestedColumns] : Object.keys(relation.target.columns);
+  if (!selectedColumns.includes(targetPrimaryKey)) {
+    selectedColumns.push(targetPrimaryKey);
+  }
+  const queryColumns = new Set(selectedColumns);
+  queryColumns.add(relation.foreignKey);
+  const selection = buildColumnSelection(
+    relation.target,
+    Array.from(queryColumns),
+    (column) => `Column '${column}' not found on relation '${relationName}'`
+  );
+  const rows = await fetchRowsForKeys(ctx, relation.target, fkColumn, keys, selection, options?.filter);
+  const grouped = groupRowsByUnique(rows, relation.foreignKey);
+  if (!requestedColumns) return grouped;
+  const visibleColumns = new Set(selectedColumns);
+  const filtered = /* @__PURE__ */ new Map();
+  for (const [key, row] of grouped.entries()) {
+    filtered.set(key, filterRow(row, visibleColumns));
+  }
+  return filtered;
 };
-var loadBelongsToRelation = async (ctx, rootTable, _relationName, relation) => {
+var loadBelongsToRelation = async (ctx, rootTable, relationName, relation, options) => {
   const roots = ctx.getEntitiesForTable(rootTable);
-  const foreignKeys = collectKeysFromRoots(roots, relation.foreignKey);
+  const getForeignKeys = () => collectKeysFromRoots(roots, relation.foreignKey);
+  let foreignKeys = getForeignKeys();
+  if (!foreignKeys.size) {
+    const pkName = findPrimaryKey(rootTable);
+    const pkColumn2 = rootTable.columns[pkName];
+    const fkColumn = rootTable.columns[relation.foreignKey];
+    if (pkColumn2 && fkColumn) {
+      const missingKeys = /* @__PURE__ */ new Set();
+      const entityByPk = /* @__PURE__ */ new Map();
+      for (const tracked of roots) {
+        const entity = tracked.entity;
+        const pkValue = entity[pkName];
+        if (pkValue === void 0 || pkValue === null) continue;
+        const fkValue = entity[relation.foreignKey];
+        if (fkValue === void 0 || fkValue === null) {
+          missingKeys.add(pkValue);
+          entityByPk.set(pkValue, entity);
+        }
+      }
+      if (missingKeys.size) {
+        const selection2 = buildColumnSelection(
+          rootTable,
+          [pkName, relation.foreignKey],
+          (column) => `Column '${column}' not found on table '${rootTable.name}'`
+        );
+        const keyRows = await fetchRowsForKeys(ctx, rootTable, pkColumn2, missingKeys, selection2);
+        for (const row of keyRows) {
+          const pkValue = row[pkName];
+          if (pkValue === void 0 || pkValue === null) continue;
+          const entity = entityByPk.get(pkValue);
+          if (!entity) continue;
+          const fkValue = row[relation.foreignKey];
+          if (fkValue !== void 0 && fkValue !== null) {
+            entity[relation.foreignKey] = fkValue;
+          }
+        }
+        foreignKeys = getForeignKeys();
+      }
+    }
+  }
   if (!foreignKeys.size) {
     return /* @__PURE__ */ new Map();
   }
   const targetKey = relation.localKey || findPrimaryKey(relation.target);
   const pkColumn = relation.target.columns[targetKey];
   if (!pkColumn) return /* @__PURE__ */ new Map();
-  const rows = await fetchRowsForKeys(ctx, relation.target, pkColumn, foreignKeys);
-  return groupRowsByUnique(rows, targetKey);
+  const requestedColumns = hasColumns(options?.columns) ? [...options.columns] : void 0;
+  const selectedColumns = requestedColumns ? [...requestedColumns] : Object.keys(relation.target.columns);
+  if (!selectedColumns.includes(targetKey)) {
+    selectedColumns.push(targetKey);
+  }
+  const selection = buildColumnSelection(
+    relation.target,
+    selectedColumns,
+    (column) => `Column '${column}' not found on relation '${relationName}'`
+  );
+  const rows = await fetchRowsForKeys(ctx, relation.target, pkColumn, foreignKeys, selection, options?.filter);
+  const grouped = groupRowsByUnique(rows, targetKey);
+  if (!requestedColumns) return grouped;
+  const visibleColumns = new Set(selectedColumns);
+  const filtered = /* @__PURE__ */ new Map();
+  for (const [key, row] of grouped.entries()) {
+    filtered.set(key, filterRow(row, visibleColumns));
+  }
+  return filtered;
 };
-var loadBelongsToManyRelation = async (ctx, rootTable, _relationName, relation) => {
+var loadBelongsToManyRelation = async (ctx, rootTable, relationName, relation, options) => {
   const rootKey = relation.localKey || findPrimaryKey(rootTable);
   const roots = ctx.getEntitiesForTable(rootTable);
   const rootIds = collectKeysFromRoots(roots, rootKey);
@@ -4730,9 +5702,29 @@ var loadBelongsToManyRelation = async (ctx, rootTable, _relationName, relation)
   }
   const pivotColumn = relation.pivotTable.columns[relation.pivotForeignKeyToRoot];
   if (!pivotColumn) return /* @__PURE__ */ new Map();
-  const pivotRows = await fetchRowsForKeys(ctx, relation.pivotTable, pivotColumn, rootIds);
+  const pivotColumnsRequested = hasColumns(options?.pivot?.columns) ? [...options.pivot.columns] : void 0;
+  const useIncludeDefaults = options !== void 0;
+  let pivotSelectedColumns;
+  if (pivotColumnsRequested) {
+    pivotSelectedColumns = [...pivotColumnsRequested];
+  } else if (useIncludeDefaults) {
+    const pivotPk = relation.pivotPrimaryKey || findPrimaryKey(relation.pivotTable);
+    pivotSelectedColumns = relation.defaultPivotColumns ?? buildDefaultPivotColumns(relation, pivotPk);
+  } else {
+    pivotSelectedColumns = Object.keys(relation.pivotTable.columns);
+  }
+  const pivotQueryColumns = new Set(pivotSelectedColumns);
+  pivotQueryColumns.add(relation.pivotForeignKeyToRoot);
+  pivotQueryColumns.add(relation.pivotForeignKeyToTarget);
+  const pivotSelection = buildColumnSelection(
+    relation.pivotTable,
+    Array.from(pivotQueryColumns),
+    (column) => `Column '${column}' not found on pivot table '${relation.pivotTable.name}'`
+  );
+  const pivotRows = await fetchRowsForKeys(ctx, relation.pivotTable, pivotColumn, rootIds, pivotSelection);
   const rootLookup = /* @__PURE__ */ new Map();
   const targetIds = /* @__PURE__ */ new Set();
+  const pivotVisibleColumns = new Set(pivotSelectedColumns);
   for (const pivot of pivotRows) {
     const rootValue = pivot[relation.pivotForeignKeyToRoot];
     const targetValue = pivot[relation.pivotForeignKeyToTarget];
@@ -4742,7 +5734,7 @@ var loadBelongsToManyRelation = async (ctx, rootTable, _relationName, relation)
     const bucket = rootLookup.get(toKey6(rootValue)) ?? [];
     bucket.push({
       targetId: targetValue,
-      pivot: { ...pivot }
+      pivot: pivotVisibleColumns.size ? filterRow(pivot, pivotVisibleColumns) : {}
     });
     rootLookup.set(toKey6(rootValue), bucket);
     targetIds.add(targetValue);
@@ -4753,8 +5745,19 @@ var loadBelongsToManyRelation = async (ctx, rootTable, _relationName, relation)
   const targetKey = relation.targetKey || findPrimaryKey(relation.target);
   const targetPkColumn = relation.target.columns[targetKey];
   if (!targetPkColumn) return /* @__PURE__ */ new Map();
-  const targetRows = await fetchRowsForKeys(ctx, relation.target, targetPkColumn, targetIds);
+  const targetRequestedColumns = hasColumns(options?.columns) ? [...options.columns] : void 0;
+  const targetSelectedColumns = targetRequestedColumns ? [...targetRequestedColumns] : Object.keys(relation.target.columns);
+  if (!targetSelectedColumns.includes(targetKey)) {
+    targetSelectedColumns.push(targetKey);
+  }
+  const targetSelection = buildColumnSelection(
+    relation.target,
+    targetSelectedColumns,
+    (column) => `Column '${column}' not found on relation '${relationName}'`
+  );
+  const targetRows = await fetchRowsForKeys(ctx, relation.target, targetPkColumn, targetIds, targetSelection, options?.filter);
   const targetMap = groupRowsByUnique(targetRows, targetKey);
+  const targetVisibleColumns = new Set(targetSelectedColumns);
   const result = /* @__PURE__ */ new Map();
   for (const [rootId, entries] of rootLookup.entries()) {
     const bucket = [];
@@ -4762,7 +5765,7 @@ var loadBelongsToManyRelation = async (ctx, rootTable, _relationName, relation)
       const targetRow = targetMap.get(toKey6(entry.targetId));
       if (!targetRow) continue;
       bucket.push({
-        ...targetRow,
+        ...targetRequestedColumns ? filterRow(targetRow, targetVisibleColumns) : targetRow,
         _pivot: entry.pivot
       });
     }
@@ -4792,12 +5795,13 @@ var relationLoaderCache = (meta, relationName, factory) => {
   }
   return promise;
 };
-var createEntityProxy = (ctx, table, row, lazyRelations = []) => {
+var createEntityProxy = (ctx, table, row, lazyRelations = [], lazyRelationOptions = /* @__PURE__ */ new Map()) => {
   const target = { ...row };
   const meta = {
     ctx,
     table,
     lazyRelations: [...lazyRelations],
+    lazyRelationOptions: new Map(lazyRelationOptions),
     relationCache: /* @__PURE__ */ new Map(),
     relationHydration: /* @__PURE__ */ new Map(),
     relationWrappers: /* @__PURE__ */ new Map()
@@ -4838,14 +5842,14 @@ var createEntityProxy = (ctx, table, row, lazyRelations = []) => {
   populateHydrationCache(proxy, row, meta);
   return proxy;
 };
-var createEntityFromRow = (ctx, table, row, lazyRelations = []) => {
+var createEntityFromRow = (ctx, table, row, lazyRelations = [], lazyRelationOptions = /* @__PURE__ */ new Map()) => {
   const pkName = findPrimaryKey(table);
   const pkValue = row[pkName];
   if (pkValue !== void 0 && pkValue !== null) {
     const tracked = ctx.getEntity(table, pkValue);
     if (tracked) return tracked;
   }
-  const entity = createEntityProxy(ctx, table, row, lazyRelations);
+  const entity = createEntityProxy(ctx, table, row, lazyRelations, lazyRelationOptions);
   if (pkValue !== void 0 && pkValue !== null) {
     ctx.trackManaged(table, pkValue, entity);
   } else {
@@ -4895,6 +5899,58 @@ var populateHydrationCache = (entity, row, meta) => {
     }
   }
 };
+var proxifyRelationWrapper = (wrapper) => {
+  return new Proxy(wrapper, {
+    get(target, prop, receiver) {
+      if (typeof prop === "symbol") {
+        return Reflect.get(target, prop, receiver);
+      }
+      if (prop in target) {
+        return Reflect.get(target, prop, receiver);
+      }
+      const getItems = target.getItems;
+      if (typeof getItems === "function") {
+        const items = getItems.call(target);
+        if (items && prop in items) {
+          const propName = prop;
+          const value = items[propName];
+          return typeof value === "function" ? value.bind(items) : value;
+        }
+      }
+      const getRef = target.get;
+      if (typeof getRef === "function") {
+        const current = getRef.call(target);
+        if (current && prop in current) {
+          const propName = prop;
+          const value = current[propName];
+          return typeof value === "function" ? value.bind(current) : value;
+        }
+      }
+      return void 0;
+    },
+    set(target, prop, value, receiver) {
+      if (typeof prop === "symbol") {
+        return Reflect.set(target, prop, value, receiver);
+      }
+      if (prop in target) {
+        return Reflect.set(target, prop, value, receiver);
+      }
+      const getRef = target.get;
+      if (typeof getRef === "function") {
+        const current = getRef.call(target);
+        if (current && typeof current === "object") {
+          return Reflect.set(current, prop, value);
+        }
+      }
+      const getItems = target.getItems;
+      if (typeof getItems === "function") {
+        const items = getItems.call(target);
+        return Reflect.set(items, prop, value);
+      }
+      return Reflect.set(target, prop, value, receiver);
+    }
+  });
+};
 var getRelationWrapper = (meta, relationName, owner) => {
   if (meta.relationWrappers.has(relationName)) {
     return meta.relationWrappers.get(relationName);
@@ -4902,12 +5958,13 @@ var getRelationWrapper = (meta, relationName, owner) => {
   const relation = meta.table.relations[relationName];
   if (!relation) return void 0;
   const wrapper = instantiateWrapper(meta, relationName, relation, owner);
-  if (wrapper) {
-    meta.relationWrappers.set(relationName, wrapper);
-  }
-  return wrapper;
+  if (!wrapper) return void 0;
+  const proxied = proxifyRelationWrapper(wrapper);
+  meta.relationWrappers.set(relationName, proxied);
+  return proxied;
 };
 var instantiateWrapper = (meta, relationName, relation, owner) => {
+  const lazyOptions = meta.lazyRelationOptions.get(relationName);
   switch (relation.type) {
     case RelationKinds.HasOne: {
       const hasOne2 = relation;
@@ -4915,7 +5972,7 @@ var instantiateWrapper = (meta, relationName, relation, owner) => {
       const loader = () => relationLoaderCache(
         meta,
         relationName,
-        () => loadHasOneRelation(meta.ctx, meta.table, relationName, hasOne2)
+        () => loadHasOneRelation(meta.ctx, meta.table, relationName, hasOne2, lazyOptions)
       );
       return new DefaultHasOneReference(
         meta.ctx,
@@ -4935,7 +5992,7 @@ var instantiateWrapper = (meta, relationName, relation, owner) => {
       const loader = () => relationLoaderCache(
         meta,
         relationName,
-        () => loadHasManyRelation(meta.ctx, meta.table, relationName, hasMany2)
+        () => loadHasManyRelation(meta.ctx, meta.table, relationName, hasMany2, lazyOptions)
       );
       return new DefaultHasManyCollection(
         meta.ctx,
@@ -4955,7 +6012,7 @@ var instantiateWrapper = (meta, relationName, relation, owner) => {
       const loader = () => relationLoaderCache(
         meta,
         relationName,
-        () => loadBelongsToRelation(meta.ctx, meta.table, relationName, belongsTo2)
+        () => loadBelongsToRelation(meta.ctx, meta.table, relationName, belongsTo2, lazyOptions)
       );
       return new DefaultBelongsToReference(
         meta.ctx,
@@ -4975,7 +6032,7 @@ var instantiateWrapper = (meta, relationName, relation, owner) => {
       const loader = () => relationLoaderCache(
         meta,
         relationName,
-        () => loadBelongsToManyRelation(meta.ctx, meta.table, relationName, many)
+        () => loadBelongsToManyRelation(meta.ctx, meta.table, relationName, many, lazyOptions)
       );
       return new DefaultManyToManyCollection(
         meta.ctx,
@@ -5014,11 +6071,17 @@ var executeWithContexts = async (execCtx, entityCtx, qb) => {
   const compiled = execCtx.dialect.compileSelect(ast);
   const executed = await execCtx.interceptors.run({ sql: compiled.sql, params: compiled.params }, execCtx.executor);
   const rows = flattenResults(executed);
+  const lazyRelations = qb.getLazyRelations();
+  const lazyRelationOptions = qb.getLazyRelationOptions();
   if (ast.setOps && ast.setOps.length > 0) {
-    return rows.map((row) => createEntityProxy(entityCtx, qb.getTable(), row, qb.getLazyRelations()));
+    const proxies = rows.map((row) => createEntityProxy(entityCtx, qb.getTable(), row, lazyRelations, lazyRelationOptions));
+    await loadLazyRelationsForTable(entityCtx, qb.getTable(), lazyRelations, lazyRelationOptions);
+    return proxies;
   }
   const hydrated = hydrateRows(rows, qb.getHydrationPlan());
-  return hydrated.map((row) => createEntityFromRow(entityCtx, qb.getTable(), row, qb.getLazyRelations()));
+  const entities = hydrated.map((row) => createEntityFromRow(entityCtx, qb.getTable(), row, lazyRelations, lazyRelationOptions));
+  await loadLazyRelationsForTable(entityCtx, qb.getTable(), lazyRelations, lazyRelationOptions);
+  return entities;
 };
 async function executeHydrated(session, qb) {
   return executeWithContexts(session.getExecutionContext(), session, qb);
@@ -5030,6 +6093,52 @@ async function executeHydratedWithContexts(execCtx, hydCtx, qb) {
   }
   return executeWithContexts(execCtx, entityCtx, qb);
 }
+var loadLazyRelationsForTable = async (ctx, table, lazyRelations, lazyRelationOptions) => {
+  if (!lazyRelations.length) return;
+  const tracked = ctx.getEntitiesForTable(table);
+  if (!tracked.length) return;
+  const meta = getEntityMeta(tracked[0].entity);
+  if (!meta) return;
+  for (const relationName of lazyRelations) {
+    const relation = table.relations[relationName];
+    if (!relation) continue;
+    const key = relationName;
+    const options = lazyRelationOptions.get(key);
+    if (!options) {
+      continue;
+    }
+    switch (relation.type) {
+      case RelationKinds.HasOne:
+        await relationLoaderCache(
+          meta,
+          key,
+          () => loadHasOneRelation(ctx, table, key, relation, options)
+        );
+        break;
+      case RelationKinds.HasMany:
+        await relationLoaderCache(
+          meta,
+          key,
+          () => loadHasManyRelation(ctx, table, key, relation, options)
+        );
+        break;
+      case RelationKinds.BelongsTo:
+        await relationLoaderCache(
+          meta,
+          key,
+          () => loadBelongsToRelation(ctx, table, key, relation, options)
+        );
+        break;
+      case RelationKinds.BelongsToMany:
+        await relationLoaderCache(
+          meta,
+          key,
+          () => loadBelongsToManyRelation(ctx, table, key, relation, options)
+        );
+        break;
+    }
+  }
+};
 
 // src/query-builder/query-resolution.ts
 function resolveSelectQuery(query) {
@@ -5046,7 +6155,7 @@ var SelectQueryBuilder = class _SelectQueryBuilder {
    * @param hydration - Optional hydration manager
    * @param dependencies - Optional query builder dependencies
    */
-  constructor(table, state, hydration, dependencies, lazyRelations) {
+  constructor(table, state, hydration, dependencies, lazyRelations, lazyRelationOptions) {
     const deps = resolveSelectQueryBuilderDependencies(dependencies);
     this.env = { table, deps };
     const initialState = state ?? deps.createState(table);
@@ -5056,6 +6165,7 @@ var SelectQueryBuilder = class _SelectQueryBuilder {
       hydration: initialHydration
     };
     this.lazyRelations = new Set(lazyRelations ?? []);
+    this.lazyRelationOptions = new Map(lazyRelationOptions ?? []);
     this.columnSelector = deps.createColumnSelector(this.env);
     this.relationManager = deps.createRelationManager(this.env);
   }
@@ -5065,8 +6175,15 @@ var SelectQueryBuilder = class _SelectQueryBuilder {
    * @param lazyRelations - Updated lazy relations set
    * @returns New SelectQueryBuilder instance
    */
-  clone(context = this.context, lazyRelations = new Set(this.lazyRelations)) {
-    return new _SelectQueryBuilder(this.env.table, context.state, context.hydration, this.env.deps, lazyRelations);
+  clone(context = this.context, lazyRelations = new Set(this.lazyRelations), lazyRelationOptions = new Map(this.lazyRelationOptions)) {
+    return new _SelectQueryBuilder(
+      this.env.table,
+      context.state,
+      context.hydration,
+      this.env.deps,
+      lazyRelations,
+      lazyRelationOptions
+    );
   }
   /**
    * Applies an alias to the root FROM table.
@@ -5313,36 +6430,40 @@ var SelectQueryBuilder = class _SelectQueryBuilder {
   /**
    * Includes a relation lazily in the query results
    * @param relationName - Name of the relation to include lazily
+   * @param options - Optional include options for lazy loading
    * @returns New query builder instance with lazy relation inclusion
    */
-  includeLazy(relationName) {
-    const nextLazy = new Set(this.lazyRelations);
-    nextLazy.add(relationName);
-    return this.clone(this.context, nextLazy);
-  }
-  /**
-   * Selects columns for a related table in a single hop.
-   */
-  selectRelationColumns(relationName, ...cols) {
+  includeLazy(relationName, options) {
+    let nextContext = this.context;
     const relation = this.env.table.relations[relationName];
-    if (!relation) {
-      throw new Error(`Relation '${relationName}' not found on table '${this.env.table.name}'`);
-    }
-    const target = relation.target;
-    for (const col2 of cols) {
-      if (!target.columns[col2]) {
-        throw new Error(
-          `Column '${col2}' not found on related table '${target.name}' for relation '${relationName}'`
-        );
+    if (relation?.type === RelationKinds.BelongsTo) {
+      const foreignKey = relation.foreignKey;
+      const fkColumn = this.env.table.columns[foreignKey];
+      if (fkColumn) {
+        const hasAlias2 = nextContext.state.ast.columns.some((col2) => {
+          const node = col2;
+          return (node.alias ?? node.name) === foreignKey;
+        });
+        if (!hasAlias2) {
+          nextContext = this.columnSelector.select(nextContext, { [foreignKey]: fkColumn });
+        }
       }
     }
-    return this.include(relationName, { columns: cols });
+    const nextLazy = new Set(this.lazyRelations);
+    nextLazy.add(relationName);
+    const nextOptions = new Map(this.lazyRelationOptions);
+    if (options) {
+      nextOptions.set(relationName, options);
+    } else {
+      nextOptions.delete(relationName);
+    }
+    return this.clone(nextContext, nextLazy, nextOptions);
   }
   /**
-   * Convenience alias for selecting specific columns from a relation.
+   * Convenience alias for including only specific columns from a relation.
    */
   includePick(relationName, cols) {
-    return this.selectRelationColumns(relationName, ...cols);
+    return this.include(relationName, { columns: cols });
   }
   /**
    * Selects columns for the root table and relations from an array of entries
@@ -5355,7 +6476,7 @@ var SelectQueryBuilder = class _SelectQueryBuilder {
       if (entry.type === "root") {
         currBuilder = currBuilder.select(...entry.columns);
       } else {
-        currBuilder = currBuilder.selectRelationColumns(entry.relationName, ...entry.columns);
+        currBuilder = currBuilder.include(entry.relationName, { columns: entry.columns });
       }
     }
     return currBuilder;
@@ -5367,6 +6488,13 @@ var SelectQueryBuilder = class _SelectQueryBuilder {
   getLazyRelations() {
     return Array.from(this.lazyRelations);
   }
+  /**
+   * Gets lazy relation include options
+   * @returns Map of relation names to include options
+   */
+  getLazyRelationOptions() {
+    return new Map(this.lazyRelationOptions);
+  }
   /**
    * Gets the table definition for this query builder
    * @returns Table definition
@@ -7791,6 +8919,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 +9485,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 +9498,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 +9521,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 +9666,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 +9822,7 @@ var TypeScriptGenerator = class {
       case "CaseExpression":
       case "WindowFunction":
       case "Cast":
+      case "Collate":
         return this.printOperand(term);
       default:
         return this.printExpression(term);
@@ -8677,6 +9885,9 @@ var TypeScriptGenerator = class {
   visitCast(node) {
     return this.printCastOperand(node);
   }
+  visitCollate(node) {
+    return this.printCollateOperand(node);
+  }
   visitAliasRef(node) {
     return `aliasRef('${node.name}')`;
   }
@@ -8688,12 +9899,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 +9933,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 +9948,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 +9993,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 +10059,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 +10092,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 +10117,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 +11246,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 +11357,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 +12187,10 @@ function createPooledExecutorFactory(opts) {
   acos,
   add,
   addDomainEvent,
+  age,
   aliasRef,
   and,
+  arrayAppend,
   ascii,
   asin,
   atan,
@@ -10968,16 +12199,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 +12268,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 +12292,16 @@ function createPooledExecutorFactory(opts) {
   isOperandNode,
   isValueOperandInput,
   isWindowFunctionNode,
+  jsonArrayAgg,
+  jsonContains,
+  jsonLength,
   jsonPath,
+  jsonSet,
   jsonify,
   lag,
   lastValue,
   lead,
+  least,
   left,
   length,
   like,
@@ -11061,9 +12310,12 @@ function createPooledExecutorFactory(opts) {
   loadBelongsToRelation,
   loadHasManyRelation,
   loadHasOneRelation,
+  localTime,
+  localTimestamp,
   locate,
   log,
   log10,
+  log2,
   logBase,
   lower,
   lpad,
@@ -11071,7 +12323,9 @@ function createPooledExecutorFactory(opts) {
   lte,
   ltrim,
   max,
+  md5,
   min,
+  minute,
   mod,
   month,
   mul,
@@ -11084,12 +12338,15 @@ function createPooledExecutorFactory(opts) {
   notLike,
   now,
   ntile,
+  nullif,
+  octetLength,
   or,
   outerRef,
   pi,
   position,
   pow,
   power,
+  quarter,
   radians,
   rand,
   random,
@@ -11097,22 +12354,30 @@ function createPooledExecutorFactory(opts) {
   registerExpressionDispatcher,
   registerOperandDispatcher,
   registerSchemaIntrospector,
+  relationLoaderCache,
   renderColumnDefinition,
   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 +12393,7 @@ function createPooledExecutorFactory(opts) {
   upper,
   utcNow,
   valueToOperand,
+  variance,
   visitExpression,
   visitOperand,
   weekOfYear,