metal-orm 1.1.23 → 1.1.24

package/dist/index.cjs

@@ -109,6 +109,11 @@ __export(index_exports, {
   SelectQueryBuilder: () => SelectQueryBuilder,
   SqlServerDialect: () => SqlServerDialect,
   SqliteDialect: () => SqliteDialect,
+  StandardDeleteCompiler: () => StandardDeleteCompiler,
+  StandardInsertCompiler: () => StandardInsertCompiler,
+  StandardSelectCompiler: () => StandardSelectCompiler,
+  StandardSqlSourceCompiler: () => StandardSqlSourceCompiler,
+  StandardUpdateCompiler: () => StandardUpdateCompiler,
   StringTypeStrategy: () => StringTypeStrategy,
   TagIndex: () => TagIndex,
   Title: () => Title,
@@ -2132,6 +2137,50 @@ var DialectBase = class _DialectBase {
   }
 };
 
+// src/core/dialect/base/pagination-strategy.ts
+var StandardLimitOffsetPagination = class {
+  /**
+   * Compiles LIMIT/OFFSET pagination clause.
+   * @param limit - The maximum number of rows to return.
+   * @param offset - The number of rows to skip.
+   * @returns SQL pagination clause with LIMIT and/or OFFSET.
+   */
+  compilePagination(limit, offset) {
+    const parts = [];
+    if (limit !== void 0) parts.push(`LIMIT ${limit}`);
+    if (offset !== void 0) parts.push(`OFFSET ${offset}`);
+    return parts.length ? ` ${parts.join(" ")}` : "";
+  }
+};
+
+// src/core/dialect/base/returning-strategy.ts
+var NoReturningStrategy = class {
+  /**
+   * Throws an error as RETURNING is not supported.
+   * @param returning - Columns to return (causes error if non-empty).
+   * @param _ctx - Compiler context (unused).
+   * @throws Error indicating RETURNING is not supported.
+   */
+  compileReturning(returning, _ctx) {
+    void _ctx;
+    if (!returning || returning.length === 0) return "";
+    throw new Error("RETURNING is not supported by this dialect.");
+  }
+  /**
+   * Formats column names for RETURNING clause.
+   * @param returning - Columns to format.
+   * @param quoteIdentifier - Function to quote identifiers according to dialect rules.
+   * @returns Simple comma-separated column names.
+   */
+  formatReturningColumns(returning, quoteIdentifier) {
+    return returning.map((column) => {
+      const tablePart = column.table ? `${quoteIdentifier(column.table)}.` : "";
+      const aliasPart = column.alias ? ` AS ${quoteIdentifier(column.alias)}` : "";
+      return `${tablePart}${quoteIdentifier(column.name)}${aliasPart}`;
+    }).join(", ");
+  }
+};
+
 // src/core/dialect/base/function-table-formatter.ts
 var FunctionTableFormatter = class {
   static format(fn9, ctx, formatter) {
@@ -2168,19 +2217,71 @@ var FunctionTableFormatter = class {
   }
 };
 
-// src/core/dialect/base/pagination-strategy.ts
-var StandardLimitOffsetPagination = class {
-  /**
-   * Compiles LIMIT/OFFSET pagination clause.
-   * @param limit - The maximum number of rows to return.
-   * @param offset - The number of rows to skip.
-   * @returns SQL pagination clause with LIMIT and/or OFFSET.
-   */
-  compilePagination(limit, offset) {
-    const parts = [];
-    if (limit !== void 0) parts.push(`LIMIT ${limit}`);
-    if (offset !== void 0) parts.push(`OFFSET ${offset}`);
-    return parts.length ? ` ${parts.join(" ")}` : "";
+// src/core/dialect/base/standard-sql-source-compiler.ts
+var StandardSqlSourceCompiler = class {
+  constructor(services) {
+    this.services = services;
+  }
+  compileFrom(source, ctx) {
+    if (source.type === "FunctionTable") return this.compileFunctionTable(source, ctx);
+    if (source.type === "DerivedTable") return this.compileDerivedTable(source, ctx);
+    return this.compileTableSource(source);
+  }
+  compileFunctionTable(fn9, ctx) {
+    const key = fn9.key ?? fn9.name;
+    if (ctx) {
+      const renderer = this.services.getTableFunctionStrategy().getRenderer(key);
+      if (renderer) {
+        const compiledArgs = (fn9.args ?? []).map((arg) => this.services.compileOperand(arg, ctx));
+        return renderer({
+          node: fn9,
+          compiledArgs,
+          compileOperand: (operand) => this.services.compileOperand(operand, ctx),
+          quoteIdentifier: (id) => this.services.quoteIdentifier(id)
+        });
+      }
+      if (fn9.key) {
+        throw new Error(
+          `Table function "${key}" is not supported by dialect "${this.services.getDialectName()}".`
+        );
+      }
+    }
+    return FunctionTableFormatter.format(fn9, ctx, {
+      quoteIdentifier: (id) => this.services.quoteIdentifier(id),
+      compileOperand: (node, compilerContext) => this.services.compileOperand(node, compilerContext)
+    });
+  }
+  compileDerivedTable(table, ctx) {
+    if (!table.alias) throw new Error("Derived tables must have an alias.");
+    if (!ctx) throw new Error("Derived table compilation requires a compiler context.");
+    const normalized = this.services.normalizeSelectAst(table.query);
+    const subquery = this.services.compileSelectAst(normalized, ctx).trim().replace(/;$/, "");
+    const columns = table.columnAliases?.length ? ` (${table.columnAliases.map((column) => this.services.quoteIdentifier(column)).join(", ")})` : "";
+    return `(${subquery}) AS ${this.services.quoteIdentifier(table.alias)}${columns}`;
+  }
+  compileTableSource(table) {
+    if (table.type === "FunctionTable") return this.compileFunctionTable(table);
+    if (table.type === "DerivedTable") {
+      throw new Error("Derived table compilation requires a compiler context.");
+    }
+    const base = this.compileTableName(table);
+    return table.alias ? `${base} AS ${this.services.quoteIdentifier(table.alias)}` : base;
+  }
+  compileTableName(table) {
+    if (table.schema) {
+      return `${this.services.quoteIdentifier(table.schema)}.${this.services.quoteIdentifier(table.name)}`;
+    }
+    return this.services.quoteIdentifier(table.name);
+  }
+  compileTableReference(table) {
+    const base = this.compileTableName(table);
+    return table.alias ? `${base} AS ${this.services.quoteIdentifier(table.alias)}` : base;
+  }
+  stripTrailingSemicolon(sql) {
+    return sql.trim().replace(/;$/, "");
+  }
+  wrapSetOperand(sql) {
+    return `(${this.stripTrailingSemicolon(sql)})`;
   }
 };
 
@@ -2210,34 +2311,6 @@ var CteCompiler = class {
   }
 };
 
-// src/core/dialect/base/returning-strategy.ts
-var NoReturningStrategy = class {
-  /**
-   * Throws an error as RETURNING is not supported.
-   * @param returning - Columns to return (causes error if non-empty).
-   * @param _ctx - Compiler context (unused).
-   * @throws Error indicating RETURNING is not supported.
-   */
-  compileReturning(returning, _ctx) {
-    void _ctx;
-    if (!returning || returning.length === 0) return "";
-    throw new Error("RETURNING is not supported by this dialect.");
-  }
-  /**
-   * Formats column names for RETURNING clause.
-   * @param returning - Columns to format.
-   * @param quoteIdentifier - Function to quote identifiers according to dialect rules.
-   * @returns Simple comma-separated column names.
-   */
-  formatReturningColumns(returning, quoteIdentifier) {
-    return returning.map((column) => {
-      const tablePart = column.table ? `${quoteIdentifier(column.table)}.` : "";
-      const aliasPart = column.alias ? ` AS ${quoteIdentifier(column.alias)}` : "";
-      return `${tablePart}${quoteIdentifier(column.name)}${aliasPart}`;
-    }).join(", ");
-  }
-};
-
 // src/core/dialect/base/join-compiler.ts
 var JoinCompiler = class {
   static compileJoins(joins, ctx, compileFrom, compileExpression) {
@@ -2288,108 +2361,229 @@ var OrderByCompiler = class {
   }
 };
 
-// src/core/dialect/base/sql-dialect.ts
-var SqlDialectBase = class extends DialectBase {
-  paginationStrategy = new StandardLimitOffsetPagination();
-  returningStrategy = new NoReturningStrategy();
-  compileSelectAst(ast, ctx) {
+// src/core/dialect/base/standard-select-compiler.ts
+var StandardSelectCompiler = class {
+  constructor(services, sources) {
+    this.services = services;
+    this.sources = sources;
+  }
+  compile(ast, ctx) {
     const hasSetOps = !!(ast.setOps && ast.setOps.length);
     const ctes = CteCompiler.compileCtes(
       ast,
       ctx,
-      this.quoteIdentifier.bind(this),
-      this.compileSelectAst.bind(this),
-      this.normalizeSelectAst.bind(this),
-      this.stripTrailingSemicolon.bind(this)
+      (id) => this.services.quoteIdentifier(id),
+      (query, compilerContext) => this.services.compileSelectAst(query, compilerContext),
+      (query) => this.services.normalizeSelectAst(query),
+      (sql) => this.sources.stripTrailingSemicolon(sql)
     );
     const baseAst = hasSetOps ? { ...ast, setOps: void 0, orderBy: void 0, limit: void 0, offset: void 0 } : ast;
-    const baseSelect = this.compileSelectCore(baseAst, ctx);
+    const baseSelect = this.compileCore(baseAst, ctx);
     if (!hasSetOps) return `${ctes}${baseSelect}`;
-    return this.compileSelectWithSetOps(ast, baseSelect, ctes, ctx);
+    const compound = ast.setOps.map((op) => `${op.operator} ${this.sources.wrapSetOperand(this.services.compileSelectAst(op.query, ctx))}`).join(" ");
+    const orderBy = this.compileOrderBy(ast, ctx);
+    const pagination = this.services.getPaginationStrategy().compilePagination(ast.limit, ast.offset);
+    const combined = `${this.sources.wrapSetOperand(baseSelect)} ${compound}`;
+    return `${ctes}${combined}${orderBy}${pagination}`;
   }
-  compileSelectWithSetOps(ast, baseSelect, ctes, ctx) {
-    const compound = ast.setOps.map((op) => `${op.operator} ${this.wrapSetOperand(this.compileSelectAst(op.query, ctx))}`).join(" ");
-    const orderBy = OrderByCompiler.compileOrderBy(
+  compileCore(ast, ctx) {
+    const columns = this.compileColumns(ast, ctx);
+    const from = this.sources.compileFrom(ast.from, ctx);
+    const joins = JoinCompiler.compileJoins(
+      ast.joins,
+      ctx,
+      (source, compilerContext) => this.sources.compileFrom(source, compilerContext),
+      (expression, compilerContext) => this.services.compileExpression(expression, compilerContext)
+    );
+    const where = ast.where ? ` WHERE ${this.services.compileExpression(ast.where, ctx)}` : "";
+    const groupBy = GroupByCompiler.compileGroupBy(
       ast,
-      (term) => this.compileOrderingTerm(term, ctx),
-      this.renderOrderByNulls.bind(this),
-      this.renderOrderByCollation.bind(this)
+      (term) => this.services.compileOrderingTerm(term, ctx)
     );
-    const pagination = this.paginationStrategy.compilePagination(ast.limit, ast.offset);
-    const combined = `${this.wrapSetOperand(baseSelect)} ${compound}`;
-    return `${ctes}${combined}${orderBy}${pagination}`;
+    const having = ast.having ? ` HAVING ${this.services.compileExpression(ast.having, ctx)}` : "";
+    const orderBy = this.compileOrderBy(ast, ctx);
+    const pagination = this.services.getPaginationStrategy().compilePagination(ast.limit, ast.offset);
+    return `SELECT ${ast.distinct ? "DISTINCT " : ""}${columns} FROM ${from}${joins}${where}${groupBy}${having}${orderBy}${pagination}`;
   }
-  compileInsertAst(ast, ctx) {
+  compileColumns(ast, ctx) {
+    if (!ast.columns || ast.columns.length === 0) return "*";
+    return ast.columns.map((column) => {
+      const expr = this.services.compileOperand(column, ctx);
+      if (!column.alias) return expr;
+      if (column.alias.includes("(")) return column.alias;
+      return `${expr} AS ${this.services.quoteIdentifier(column.alias)}`;
+    }).join(", ");
+  }
+  compileOrderBy(ast, ctx) {
+    return OrderByCompiler.compileOrderBy(
+      ast,
+      (term) => this.services.compileOrderingTerm(term, ctx),
+      (order) => this.services.renderOrderByNulls(order),
+      (order) => this.services.renderOrderByCollation(order)
+    );
+  }
+};
+
+// src/core/dialect/base/standard-insert-compiler.ts
+var StandardInsertCompiler = class {
+  constructor(services, sources) {
+    this.services = services;
+    this.sources = sources;
+  }
+  compile(ast, ctx) {
     if (!ast.columns.length) {
       throw new Error("INSERT queries must specify columns.");
     }
-    const table = this.compileTableName(ast.into);
-    const columnList = this.compileInsertColumnList(ast.columns);
-    const source = this.compileInsertSource(ast.source, ctx);
-    const upsert = this.compileUpsertClause(ast, ctx);
-    const returning = this.compileReturning(ast.returning, ctx);
+    const table = this.sources.compileTableName(ast.into);
+    const columnList = this.compileColumnList(ast.columns);
+    const source = this.compileSource(ast.source, ctx);
+    const upsert = this.services.compileUpsertClause(ast, ctx);
+    const returning = this.services.compileReturning(ast.returning, ctx);
     return `INSERT INTO ${table} (${columnList}) ${source}${upsert}${returning}`;
   }
-  compileUpsertClause(ast, _ctx) {
-    void _ctx;
-    if (!ast.onConflict) return "";
-    throw new Error(`UPSERT/ON CONFLICT is not supported by dialect "${this.dialect}".`);
-  }
-  compileReturning(returning, ctx) {
-    return this.returningStrategy.compileReturning(returning, ctx);
-  }
-  compileInsertSource(source, ctx) {
+  compileSource(source, ctx) {
     if (source.type === "InsertValues") {
       if (!source.rows.length) {
         throw new Error("INSERT ... VALUES requires at least one row.");
       }
-      const values = source.rows.map((row) => `(${row.map((value) => this.compileOperand(value, ctx)).join(", ")})`).join(", ");
+      const values = source.rows.map((row) => `(${row.map((value) => this.services.compileOperand(value, ctx)).join(", ")})`).join(", ");
       return `VALUES ${values}`;
     }
-    const normalized = this.normalizeSelectAst(source.query);
-    return this.compileSelectAst(normalized, ctx).trim();
+    const normalized = this.services.normalizeSelectAst(source.query);
+    return this.services.compileSelectAst(normalized, ctx).trim();
   }
-  compileInsertColumnList(columns) {
-    return columns.map((column) => this.quoteIdentifier(column.name)).join(", ");
+  compileColumnList(columns) {
+    return columns.map((column) => this.services.quoteIdentifier(column.name)).join(", ");
   }
   ensureConflictColumns(clause, message) {
     if (!clause.target.columns.length) throw new Error(message);
   }
-  compileSelectCore(ast, ctx) {
-    const columns = this.compileSelectColumns(ast, ctx);
-    const from = this.compileFrom(ast.from, ctx);
+};
+
+// src/core/dialect/base/standard-update-compiler.ts
+var StandardUpdateCompiler = class {
+  constructor(services, sources) {
+    this.services = services;
+    this.sources = sources;
+  }
+  compile(ast, ctx) {
+    const target = this.sources.compileTableReference(ast.table);
+    const assignments = this.compileAssignments(ast.set, ast.table, ctx);
+    const from = this.compileFromClause(ast, ctx);
+    const where = ast.where ? ` WHERE ${this.services.compileExpression(ast.where, ctx)}` : "";
+    const returning = this.services.compileReturning(ast.returning, ctx);
+    return `UPDATE ${target} SET ${assignments}${from}${where}${returning}`;
+  }
+  compileAssignments(assignments, table, ctx) {
+    return assignments.map((assignment) => {
+      const target = this.services.compileSetTarget(assignment.column, table);
+      const value = this.services.compileOperand(assignment.value, ctx);
+      return `${target} = ${value}`;
+    }).join(", ");
+  }
+  compileFromClause(ast, ctx) {
+    if (!ast.from && (!ast.joins || ast.joins.length === 0)) return "";
+    if (!ast.from) {
+      throw new Error("UPDATE with JOINs requires an explicit FROM clause.");
+    }
+    const from = this.sources.compileFrom(ast.from, ctx);
     const joins = JoinCompiler.compileJoins(
       ast.joins,
       ctx,
-      this.compileFrom.bind(this),
-      this.compileExpression.bind(this)
+      (source, compilerContext) => this.sources.compileFrom(source, compilerContext),
+      (expression, compilerContext) => this.services.compileExpression(expression, compilerContext)
     );
-    const whereClause = this.compileWhere(ast.where, ctx);
-    const groupBy = GroupByCompiler.compileGroupBy(ast, (term) => this.compileOrderingTerm(term, ctx));
-    const having = this.compileHaving(ast, ctx);
-    const orderBy = OrderByCompiler.compileOrderBy(
-      ast,
-      (term) => this.compileOrderingTerm(term, ctx),
-      this.renderOrderByNulls.bind(this),
-      this.renderOrderByCollation.bind(this)
+    return ` FROM ${from}${joins}`;
+  }
+};
+
+// src/core/dialect/base/standard-delete-compiler.ts
+var StandardDeleteCompiler = class {
+  constructor(services, sources) {
+    this.services = services;
+    this.sources = sources;
+  }
+  compile(ast, ctx) {
+    const target = this.sources.compileTableReference(ast.from);
+    const using = this.compileUsingClause(ast, ctx);
+    const where = ast.where ? ` WHERE ${this.services.compileExpression(ast.where, ctx)}` : "";
+    const returning = this.services.compileReturning(ast.returning, ctx);
+    return `DELETE FROM ${target}${using}${where}${returning}`;
+  }
+  compileUsingClause(ast, ctx) {
+    if (!ast.using && (!ast.joins || ast.joins.length === 0)) return "";
+    if (!ast.using) {
+      throw new Error("DELETE with JOINs requires a USING clause.");
+    }
+    const usingTable = this.sources.compileFrom(ast.using, ctx);
+    const joins = JoinCompiler.compileJoins(
+      ast.joins,
+      ctx,
+      (source, compilerContext) => this.sources.compileFrom(source, compilerContext),
+      (expression, compilerContext) => this.services.compileExpression(expression, compilerContext)
     );
-    const pagination = this.paginationStrategy.compilePagination(ast.limit, ast.offset);
-    return `SELECT ${this.compileDistinct(ast)}${columns} FROM ${from}${joins}${whereClause}${groupBy}${having}${orderBy}${pagination}`;
+    return ` USING ${usingTable}${joins}`;
+  }
+};
+
+// src/core/dialect/base/sql-dialect.ts
+var SqlDialectBase = class extends DialectBase {
+  paginationStrategy = new StandardLimitOffsetPagination();
+  returningStrategy = new NoReturningStrategy();
+  sourceCompiler;
+  selectCompiler;
+  insertCompiler;
+  updateCompiler;
+  deleteCompiler;
+  constructor(functionStrategy, tableFunctionStrategy) {
+    super(functionStrategy, tableFunctionStrategy);
+    const services = {
+      getDialectName: () => this.dialect,
+      getPaginationStrategy: () => this.paginationStrategy,
+      getTableFunctionStrategy: () => this.tableFunctionStrategy,
+      quoteIdentifier: (id) => this.quoteIdentifier(id),
+      compileOperand: (node, ctx) => this.compileOperand(node, ctx),
+      compileExpression: (node, ctx) => this.compileExpression(node, ctx),
+      compileOrderingTerm: (term, ctx) => this.compileOrderingTerm(term, ctx),
+      normalizeSelectAst: (ast) => this.normalizeSelectAst(ast),
+      compileSelectAst: (ast, ctx) => this.compileSelectAst(ast, ctx),
+      compileReturning: (returning, ctx) => this.compileReturning(returning, ctx),
+      compileUpsertClause: (ast, ctx) => this.compileUpsertClause(ast, ctx),
+      compileSetTarget: (column, table) => this.compileSetTarget(column, table),
+      renderOrderByNulls: (order) => this.renderOrderByNulls(order),
+      renderOrderByCollation: (order) => this.renderOrderByCollation(order)
+    };
+    this.sourceCompiler = new StandardSqlSourceCompiler(services);
+    this.selectCompiler = new StandardSelectCompiler(services, this.sourceCompiler);
+    this.insertCompiler = new StandardInsertCompiler(services, this.sourceCompiler);
+    this.updateCompiler = new StandardUpdateCompiler(services, this.sourceCompiler);
+    this.deleteCompiler = new StandardDeleteCompiler(services, this.sourceCompiler);
+  }
+  compileSelectAst(ast, ctx) {
+    return this.selectCompiler.compile(ast, ctx);
+  }
+  compileInsertAst(ast, ctx) {
+    return this.insertCompiler.compile(ast, ctx);
   }
   compileUpdateAst(ast, ctx) {
-    const target = this.compileTableReference(ast.table);
-    const assignments = this.compileUpdateAssignments(ast.set, ast.table, ctx);
-    const fromClause = this.compileUpdateFromClause(ast, ctx);
-    const whereClause = this.compileWhere(ast.where, ctx);
-    const returning = this.compileReturning(ast.returning, ctx);
-    return `UPDATE ${target} SET ${assignments}${fromClause}${whereClause}${returning}`;
+    return this.updateCompiler.compile(ast, ctx);
+  }
+  compileDeleteAst(ast, ctx) {
+    return this.deleteCompiler.compile(ast, ctx);
+  }
+  compileUpsertClause(ast, _ctx) {
+    void _ctx;
+    if (!ast.onConflict) return "";
+    throw new Error(`UPSERT/ON CONFLICT is not supported by dialect "${this.dialect}".`);
+  }
+  compileReturning(returning, ctx) {
+    return this.returningStrategy.compileReturning(returning, ctx);
+  }
+  ensureConflictColumns(clause, message) {
+    this.insertCompiler.ensureConflictColumns(clause, message);
   }
   compileUpdateAssignments(assignments, table, ctx) {
-    return assignments.map((assignment) => {
-      const target = this.compileSetTarget(assignment.column, table);
-      const value = this.compileOperand(assignment.value, ctx);
-      return `${target} = ${value}`;
-    }).join(", ");
+    return this.updateCompiler.compileAssignments(assignments, table, ctx);
   }
   compileSetTarget(column, table) {
     return this.compileQualifiedColumn(column, table);
@@ -2402,112 +2596,35 @@ var SqlDialectBase = class extends DialectBase {
     if (!tableQualifier) return this.quoteIdentifier(column.name);
     return `${this.quoteIdentifier(tableQualifier)}.${this.quoteIdentifier(column.name)}`;
   }
-  compileDeleteAst(ast, ctx) {
-    const target = this.compileTableReference(ast.from);
-    const usingClause = this.compileDeleteUsingClause(ast, ctx);
-    const whereClause = this.compileWhere(ast.where, ctx);
-    const returning = this.compileReturning(ast.returning, ctx);
-    return `DELETE FROM ${target}${usingClause}${whereClause}${returning}`;
-  }
   formatReturningColumns(returning) {
-    return this.returningStrategy.formatReturningColumns(returning, this.quoteIdentifier.bind(this));
-  }
-  compileDistinct(ast) {
-    return ast.distinct ? "DISTINCT " : "";
-  }
-  compileSelectColumns(ast, ctx) {
-    if (!ast.columns || ast.columns.length === 0) return "*";
-    return ast.columns.map((column) => {
-      const expr = this.compileOperand(column, ctx);
-      if (column.alias) {
-        if (column.alias.includes("(")) return column.alias;
-        return `${expr} AS ${this.quoteIdentifier(column.alias)}`;
-      }
-      return expr;
-    }).join(", ");
+    return this.returningStrategy.formatReturningColumns(
+      returning,
+      (id) => this.quoteIdentifier(id)
+    );
   }
-  compileFrom(ast, ctx) {
-    if (ast.type === "FunctionTable") return this.compileFunctionTable(ast, ctx);
-    if (ast.type === "DerivedTable") return this.compileDerivedTable(ast, ctx);
-    return this.compileTableSource(ast);
+  compileFrom(source, ctx) {
+    return this.sourceCompiler.compileFrom(source, ctx);
   }
   compileFunctionTable(fn9, ctx) {
-    const key = fn9.key ?? fn9.name;
-    if (ctx) {
-      const renderer = this.tableFunctionStrategy.getRenderer(key);
-      if (renderer) {
-        const compiledArgs = (fn9.args ?? []).map((arg) => this.compileOperand(arg, ctx));
-        return renderer({
-          node: fn9,
-          compiledArgs,
-          compileOperand: (operand) => this.compileOperand(operand, ctx),
-          quoteIdentifier: this.quoteIdentifier.bind(this)
-        });
-      }
-      if (fn9.key) {
-        throw new Error(`Table function "${key}" is not supported by dialect "${this.dialect}".`);
-      }
-    }
-    return FunctionTableFormatter.format(fn9, ctx, {
-      quoteIdentifier: (id) => this.quoteIdentifier(id),
-      compileOperand: (node, compilerContext) => this.compileOperand(node, compilerContext)
-    });
+    return this.sourceCompiler.compileFunctionTable(fn9, ctx);
   }
   compileDerivedTable(table, ctx) {
-    if (!table.alias) throw new Error("Derived tables must have an alias.");
-    const subquery = this.compileSelectAst(this.normalizeSelectAst(table.query), ctx).trim().replace(/;$/, "");
-    const columns = table.columnAliases?.length ? ` (${table.columnAliases.map((c) => this.quoteIdentifier(c)).join(", ")})` : "";
-    return `(${subquery}) AS ${this.quoteIdentifier(table.alias)}${columns}`;
+    return this.sourceCompiler.compileDerivedTable(table, ctx);
   }
   compileTableSource(table) {
-    if (table.type === "FunctionTable") return this.compileFunctionTable(table);
-    if (table.type === "DerivedTable") return this.compileDerivedTable(table);
-    const base = this.compileTableName(table);
-    return table.alias ? `${base} AS ${this.quoteIdentifier(table.alias)}` : base;
+    return this.sourceCompiler.compileTableSource(table);
   }
   compileTableName(table) {
-    if (table.schema) {
-      return `${this.quoteIdentifier(table.schema)}.${this.quoteIdentifier(table.name)}`;
-    }
-    return this.quoteIdentifier(table.name);
+    return this.sourceCompiler.compileTableName(table);
   }
   compileTableReference(table) {
-    const base = this.compileTableName(table);
-    return table.alias ? `${base} AS ${this.quoteIdentifier(table.alias)}` : base;
-  }
-  compileUpdateFromClause(ast, ctx) {
-    if (!ast.from && (!ast.joins || ast.joins.length === 0)) return "";
-    if (!ast.from) throw new Error("UPDATE with JOINs requires an explicit FROM clause.");
-    const from = this.compileFrom(ast.from, ctx);
-    const joins = JoinCompiler.compileJoins(
-      ast.joins,
-      ctx,
-      this.compileFrom.bind(this),
-      this.compileExpression.bind(this)
-    );
-    return ` FROM ${from}${joins}`;
-  }
-  compileDeleteUsingClause(ast, ctx) {
-    if (!ast.using && (!ast.joins || ast.joins.length === 0)) return "";
-    if (!ast.using) throw new Error("DELETE with JOINs requires a USING clause.");
-    const usingTable = this.compileFrom(ast.using, ctx);
-    const joins = JoinCompiler.compileJoins(
-      ast.joins,
-      ctx,
-      this.compileFrom.bind(this),
-      this.compileExpression.bind(this)
-    );
-    return ` USING ${usingTable}${joins}`;
-  }
-  compileHaving(ast, ctx) {
-    if (!ast.having) return "";
-    return ` HAVING ${this.compileExpression(ast.having, ctx)}`;
+    return this.sourceCompiler.compileTableReference(table);
   }
   stripTrailingSemicolon(sql) {
-    return sql.trim().replace(/;$/, "");
+    return this.sourceCompiler.stripTrailingSemicolon(sql);
   }
   wrapSetOperand(sql) {
-    return `(${this.stripTrailingSemicolon(sql)})`;
+    return this.sourceCompiler.wrapSetOperand(sql);
   }
   renderOrderByNulls(order) {
     return order.nulls ? ` NULLS ${order.nulls}` : "";
@@ -22122,6 +22239,11 @@ async function bulkUpsert(session, table, rows, options = {}) {
   SelectQueryBuilder,
   SqlServerDialect,
   SqliteDialect,
+  StandardDeleteCompiler,
+  StandardInsertCompiler,
+  StandardSelectCompiler,
+  StandardSqlSourceCompiler,
+  StandardUpdateCompiler,
   StringTypeStrategy,
   TagIndex,
   Title,