metal-orm 1.1.23 → 1.1.25

package/dist/index.js

@@ -1686,6 +1686,57 @@ 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 {
+  compileReturning(returning, _ctx, _quoteIdentifier) {
+    void _ctx;
+    void _quoteIdentifier;
+    if (!returning || returning.length === 0) return "";
+    throw new Error("RETURNING is not supported by this dialect.");
+  }
+  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(", ");
+  }
+};
+var StandardReturningStrategy = class extends NoReturningStrategy {
+  compileReturning(returning, _ctx, quoteIdentifier) {
+    void _ctx;
+    if (!returning || returning.length === 0) return "";
+    return ` RETURNING ${this.formatReturningColumns(returning, quoteIdentifier)}`;
+  }
+};
+
+// src/core/dialect/base/upsert-strategy.ts
+var NoUpsertStrategy = class {
+  compile(ast, _ctx, services) {
+    void _ctx;
+    if (!ast.onConflict) return "";
+    throw new Error(
+      `UPSERT/ON CONFLICT is not supported by dialect "${services.getDialectName()}".`
+    );
+  }
+};
+
 // src/core/dialect/base/function-table-formatter.ts
 var FunctionTableFormatter = class {
   static format(fn9, ctx, formatter) {
@@ -1722,19 +1773,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)})`;
   }
 };
 
@@ -1764,34 +1867,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) {
@@ -1842,108 +1917,254 @@ 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}`;
+  }
+  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.services.compileOrderingTerm(term, ctx)
+    );
+    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}`;
   }
-  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(
+  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.compileOrderingTerm(term, ctx),
-      this.renderOrderByNulls.bind(this),
-      this.renderOrderByCollation.bind(this)
+      (term) => this.services.compileOrderingTerm(term, ctx),
+      (order) => this.services.renderOrderByNulls(order),
+      (order) => this.services.renderOrderByCollation(order)
     );
-    const pagination = this.paginationStrategy.compilePagination(ast.limit, ast.offset);
-    const combined = `${this.wrapSetOperand(baseSelect)} ${compound}`;
-    return `${ctes}${combined}${orderBy}${pagination}`;
   }
-  compileInsertAst(ast, ctx) {
+};
+
+// 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;
+  returningStrategy;
+  upsertStrategy;
+  dmlReturningSupported;
+  sourceCompiler;
+  standardUpdateCompiler;
+  compilerSet;
+  constructor(options = {}) {
+    super(options.functionStrategy, options.tableFunctionStrategy);
+    this.paginationStrategy = options.paginationStrategy ?? new StandardLimitOffsetPagination();
+    this.returningStrategy = options.returningStrategy ?? new NoReturningStrategy();
+    this.upsertStrategy = options.upsertStrategy ?? new NoUpsertStrategy();
+    this.dmlReturningSupported = options.supportsDmlReturning ?? false;
+    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);
+    const standardSelect = new StandardSelectCompiler(services, this.sourceCompiler);
+    const standardInsert = new StandardInsertCompiler(services, this.sourceCompiler);
+    this.standardUpdateCompiler = new StandardUpdateCompiler(services, this.sourceCompiler);
+    const standardDelete = new StandardDeleteCompiler(services, this.sourceCompiler);
+    const overrides = options.compilerFactory?.({
+      services,
+      sources: this.sourceCompiler
+    }) ?? {};
+    this.compilerSet = {
+      select: overrides.select ?? standardSelect,
+      insert: overrides.insert ?? standardInsert,
+      update: overrides.update ?? this.standardUpdateCompiler,
+      delete: overrides.delete ?? standardDelete
+    };
+  }
+  supportsDmlReturningClause() {
+    return this.dmlReturningSupported;
+  }
+  compileSelectAst(ast, ctx) {
+    return this.compilerSet.select.compile(ast, ctx);
+  }
+  compileInsertAst(ast, ctx) {
+    return this.compilerSet.insert.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.compilerSet.update.compile(ast, ctx);
+  }
+  compileDeleteAst(ast, ctx) {
+    return this.compilerSet.delete.compile(ast, ctx);
+  }
+  compileUpsertClause(ast, ctx) {
+    return this.upsertStrategy.compile(ast, ctx, {
+      getDialectName: () => this.dialect,
+      quoteIdentifier: (id) => this.quoteIdentifier(id),
+      compileOperand: (node, compilerContext) => this.compileOperand(node, compilerContext),
+      compileExpression: (node, compilerContext) => this.compileExpression(node, compilerContext),
+      compileUpdateAssignments: (assignments, table, compilerContext) => this.standardUpdateCompiler.compileAssignments(assignments, table, compilerContext)
+    });
+  }
+  compileReturning(returning, ctx) {
+    return this.returningStrategy.compileReturning(
+      returning,
+      ctx,
+      (id) => this.quoteIdentifier(id)
+    );
+  }
+  ensureConflictColumns(clause, message) {
+    if (!clause.target.columns.length) throw new Error(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.standardUpdateCompiler.compileAssignments(assignments, table, ctx);
   }
   compileSetTarget(column, table) {
     return this.compileQualifiedColumn(column, table);
@@ -1956,112 +2177,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}` : "";
@@ -2246,105 +2390,112 @@ var PostgresTableFunctionStrategy = class extends StandardTableFunctionStrategy
   }
 };
 
+// src/core/dialect/postgres/procedure-compiler.ts
+var PostgresProcedureCompiler = class {
+  constructor(services) {
+    this.services = services;
+  }
+  compileProcedureCall(ast) {
+    const ctx = this.services.createCompilerContext();
+    const qualifiedName = ast.ref.schema ? `${this.services.quoteIdentifier(ast.ref.schema)}.${this.services.quoteIdentifier(ast.ref.name)}` : this.services.quoteIdentifier(ast.ref.name);
+    const args = [];
+    for (const param of ast.params) {
+      if (param.direction === "out") continue;
+      if (!param.value) {
+        throw new Error(
+          `Procedure parameter "${param.name}" requires a value for direction "${param.direction}".`
+        );
+      }
+      args.push(this.services.compileOperand(param.value, ctx));
+    }
+    const outNames = ast.params.filter((param) => param.direction === "out" || param.direction === "inout").map((param) => param.name);
+    return {
+      sql: `CALL ${qualifiedName}(${args.join(", ")});`,
+      params: [...ctx.params],
+      outParams: {
+        source: outNames.length ? "firstResultSet" : "none",
+        names: outNames
+      }
+    };
+  }
+};
+
+// src/core/dialect/postgres/returning.ts
+var PostgresReturningStrategy = class extends StandardReturningStrategy {
+};
+
+// src/core/dialect/postgres/upsert.ts
+var PostgresUpsertStrategy = class {
+  compile(ast, ctx, services) {
+    if (!ast.onConflict) return "";
+    const clause = ast.onConflict;
+    const target = clause.target.constraint ? ` ON CONFLICT ON CONSTRAINT ${services.quoteIdentifier(clause.target.constraint)}` : (() => {
+      if (!clause.target.columns.length) {
+        throw new Error("PostgreSQL ON CONFLICT requires conflict columns or a constraint name.");
+      }
+      const columns = clause.target.columns.map((column) => services.quoteIdentifier(column.name)).join(", ");
+      return ` ON CONFLICT (${columns})`;
+    })();
+    if (clause.action.type === "DoNothing") {
+      return `${target} DO NOTHING`;
+    }
+    if (!clause.action.set.length) {
+      throw new Error("PostgreSQL ON CONFLICT DO UPDATE requires at least one assignment.");
+    }
+    const assignments = services.compileUpdateAssignments(clause.action.set, ast.into, ctx);
+    const where = clause.action.where ? ` WHERE ${services.compileExpression(clause.action.where, ctx)}` : "";
+    return `${target} DO UPDATE SET ${assignments}${where}`;
+  }
+};
+
 // src/core/dialect/postgres/index.ts
 var PostgresDialect = class extends SqlDialectBase {
   dialect = "postgres";
-  /**
-   * Creates a new PostgresDialect instance
-   */
+  procedureCompiler;
   constructor() {
-    super(new PostgresFunctionStrategy(), new PostgresTableFunctionStrategy());
+    super({
+      functionStrategy: new PostgresFunctionStrategy(),
+      tableFunctionStrategy: new PostgresTableFunctionStrategy(),
+      returningStrategy: new PostgresReturningStrategy(),
+      upsertStrategy: new PostgresUpsertStrategy(),
+      supportsDmlReturning: true
+    });
+    this.procedureCompiler = new PostgresProcedureCompiler({
+      quoteIdentifier: (id) => this.quoteIdentifier(id),
+      createCompilerContext: () => this.createCompilerContext(),
+      compileOperand: (node, ctx) => this.compileOperand(node, ctx)
+    });
     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}`;
+      const operator = node.operator === "^" ? "#" : node.operator;
+      return `${left2} ${operator} ${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})`;
+      const operator = node.operator === "^" ? "#" : node.operator;
+      return `(${left2} ${operator} ${right2})`;
     });
   }
-  /**
-   * Quotes an identifier using PostgreSQL double-quote syntax
-   * @param id - Identifier to quote
-   * @returns Quoted identifier
-   */
   quoteIdentifier(id) {
     return `"${id}"`;
   }
   formatPlaceholder(index) {
     return `$${index}`;
   }
-  /**
-   * Compiles JSON path expression using PostgreSQL syntax
-   * @param node - JSON path node
-   * @returns PostgreSQL JSON path expression
-   */
   compileJsonPath(node) {
-    const col2 = `${this.quoteIdentifier(node.column.table)}.${this.quoteIdentifier(node.column.name)}`;
-    return `${col2}->>'${node.path}'`;
-  }
-  compileReturning(returning, ctx) {
-    void ctx;
-    if (!returning || returning.length === 0) return "";
-    const columns = this.formatReturningColumns(returning);
-    return ` RETURNING ${columns}`;
-  }
-  compileUpsertClause(ast, ctx) {
-    if (!ast.onConflict) return "";
-    const clause = ast.onConflict;
-    const target = clause.target.constraint ? ` ON CONFLICT ON CONSTRAINT ${this.quoteIdentifier(clause.target.constraint)}` : (() => {
-      this.ensureConflictColumns(
-        clause,
-        "PostgreSQL ON CONFLICT requires conflict columns or a constraint name."
-      );
-      const cols = clause.target.columns.map((col2) => this.quoteIdentifier(col2.name)).join(", ");
-      return ` ON CONFLICT (${cols})`;
-    })();
-    if (clause.action.type === "DoNothing") {
-      return `${target} DO NOTHING`;
-    }
-    if (!clause.action.set.length) {
-      throw new Error("PostgreSQL ON CONFLICT DO UPDATE requires at least one assignment.");
-    }
-    const assignments = this.compileUpdateAssignments(clause.action.set, ast.into, ctx);
-    const where = clause.action.where ? ` WHERE ${this.compileExpression(clause.action.where, ctx)}` : "";
-    return `${target} DO UPDATE SET ${assignments}${where}`;
-  }
-  supportsDmlReturningClause() {
-    return true;
-  }
-  compileProcedureCall(ast) {
-    const ctx = this.createCompilerContext();
-    const qualifiedName = ast.ref.schema ? `${this.quoteIdentifier(ast.ref.schema)}.${this.quoteIdentifier(ast.ref.name)}` : this.quoteIdentifier(ast.ref.name);
-    const args = [];
-    for (const param of ast.params) {
-      if (param.direction === "out") continue;
-      if (!param.value) {
-        throw new Error(`Procedure parameter "${param.name}" requires a value for direction "${param.direction}".`);
-      }
-      args.push(this.compileOperand(param.value, ctx));
-    }
-    const outNames = ast.params.filter((param) => param.direction === "out" || param.direction === "inout").map((param) => param.name);
-    const rawSql = `CALL ${qualifiedName}(${args.join(", ")})`;
-    return {
-      sql: `${rawSql};`,
-      params: [...ctx.params],
-      outParams: {
-        source: outNames.length ? "firstResultSet" : "none",
-        names: outNames
-      }
-    };
+    const column = `${this.quoteIdentifier(node.column.table)}.${this.quoteIdentifier(node.column.name)}`;
+    return `${column}->>'${node.path}'`;
   }
-  /**
-   * PostgreSQL requires unqualified column names in SET clause
-   */
+  /** PostgreSQL requires unqualified column names in SET clauses. */
   compileSetTarget(column, _table) {
+    void _table;
     return this.quoteIdentifier(column.name);
   }
+  compileProcedureCall(ast) {
+    return this.procedureCompiler.compileProcedureCall(ast);
+  }
 };
 
 // src/core/dialect/mysql/functions.ts
@@ -2445,72 +2596,15 @@ var MysqlFunctionStrategy = class extends StandardFunctionStrategy {
   }
 };
 
-// src/core/dialect/mysql/index.ts
+// src/core/dialect/mysql/procedure-compiler.ts
 var sanitizeVariableSuffix = (value) => value.replace(/[^a-zA-Z0-9_]/g, "_");
-var MySqlDialect = class extends SqlDialectBase {
-  dialect = "mysql";
-  /**
-   * Creates a new MySqlDialect instance
-   */
-  constructor() {
-    super(new MysqlFunctionStrategy());
-    this.registerExpressionCompiler(
-      "IsDistinctExpression",
-      (node, ctx) => {
-        const left2 = this.compileOperand(node.left, ctx);
-        const right2 = this.compileOperand(node.right, ctx);
-        const spaceship = `${left2} <=> ${right2}`;
-        if (node.operator === "IS NOT DISTINCT FROM") {
-          return spaceship;
-        }
-        return `NOT (${spaceship})`;
-      }
-    );
-  }
-  /**
-   * Quotes an identifier using MySQL backtick syntax
-   * @param id - Identifier to quote
-   * @returns Quoted identifier
-   */
-  quoteIdentifier(id) {
-    return `\`${id}\``;
-  }
-  /**
-   * Compiles JSON path expression using MySQL syntax
-   * @param node - JSON path node
-   * @returns MySQL JSON path expression
-   */
-  compileJsonPath(node) {
-    const col2 = `${this.quoteIdentifier(node.column.table)}.${this.quoteIdentifier(node.column.name)}`;
-    return `${col2}->'${node.path}'`;
-  }
-  compileUpsertClause(ast, ctx) {
-    if (!ast.onConflict) return "";
-    const clause = ast.onConflict;
-    if (clause.action.type === "DoNothing") {
-      const noOpColumn = clause.target.columns[0] ?? ast.columns[0];
-      if (!noOpColumn) {
-        throw new Error("MySQL ON DUPLICATE KEY UPDATE requires at least one target column.");
-      }
-      const col2 = this.quoteIdentifier(noOpColumn.name);
-      return ` ON DUPLICATE KEY UPDATE ${col2} = ${col2}`;
-    }
-    if (clause.action.where) {
-      throw new Error("MySQL ON DUPLICATE KEY UPDATE does not support a WHERE clause.");
-    }
-    if (!clause.action.set.length) {
-      throw new Error("MySQL ON DUPLICATE KEY UPDATE requires at least one assignment.");
-    }
-    const assignments = clause.action.set.map((assignment) => {
-      const target = this.quoteIdentifier(assignment.column.name);
-      const value = this.compileOperand(assignment.value, ctx);
-      return `${target} = ${value}`;
-    }).join(", ");
-    return ` ON DUPLICATE KEY UPDATE ${assignments}`;
+var MySqlProcedureCompiler = class {
+  constructor(services) {
+    this.services = services;
   }
   compileProcedureCall(ast) {
-    const ctx = this.createCompilerContext();
-    const qualifiedName = ast.ref.schema ? `${this.quoteIdentifier(ast.ref.schema)}.${this.quoteIdentifier(ast.ref.name)}` : this.quoteIdentifier(ast.ref.name);
+    const ctx = this.services.createCompilerContext();
+    const qualifiedName = ast.ref.schema ? `${this.services.quoteIdentifier(ast.ref.schema)}.${this.services.quoteIdentifier(ast.ref.name)}` : this.services.quoteIdentifier(ast.ref.name);
     const prelude = [];
     const callArgs = [];
     const outVars = [];
@@ -2521,35 +2615,97 @@ var MySqlDialect = class extends SqlDialectBase {
         if (!param.value) {
           throw new Error(`Procedure parameter "${param.name}" requires a value for direction "in".`);
         }
-        callArgs.push(this.compileOperand(param.value, ctx));
+        callArgs.push(this.services.compileOperand(param.value, ctx));
         return;
       }
       if (param.direction === "inout") {
         if (!param.value) {
           throw new Error(`Procedure parameter "${param.name}" requires a value for direction "inout".`);
         }
-        prelude.push(`SET ${variable} = ${this.compileOperand(param.value, ctx)};`);
+        prelude.push(`SET ${variable} = ${this.services.compileOperand(param.value, ctx)};`);
       }
       callArgs.push(variable);
       outVars.push({ variable, name: param.name });
     });
     const statements = [];
-    if (prelude.length) {
-      statements.push(...prelude);
+    if (prelude.length) statements.push(...prelude);
+    statements.push(`CALL ${qualifiedName}(${callArgs.join(", ")});`);
+    if (outVars.length) {
+      const selectOut = outVars.map(({ variable, name }) => `${variable} AS ${this.services.quoteIdentifier(name)}`).join(", ");
+      statements.push(`SELECT ${selectOut};`);
+    }
+    return {
+      sql: statements.join(" "),
+      params: [...ctx.params],
+      outParams: {
+        source: outVars.length ? "lastResultSet" : "none",
+        names: outVars.map((item) => item.name)
+      }
+    };
+  }
+};
+
+// src/core/dialect/mysql/upsert.ts
+var MySqlUpsertStrategy = class {
+  compile(ast, ctx, services) {
+    if (!ast.onConflict) return "";
+    const clause = ast.onConflict;
+    if (clause.action.type === "DoNothing") {
+      const noOpColumn = clause.target.columns[0] ?? ast.columns[0];
+      if (!noOpColumn) {
+        throw new Error("MySQL ON DUPLICATE KEY UPDATE requires at least one target column.");
+      }
+      const col2 = services.quoteIdentifier(noOpColumn.name);
+      return ` ON DUPLICATE KEY UPDATE ${col2} = ${col2}`;
+    }
+    if (clause.action.where) {
+      throw new Error("MySQL ON DUPLICATE KEY UPDATE does not support a WHERE clause.");
     }
-    statements.push(`CALL ${qualifiedName}(${callArgs.join(", ")});`);
-    if (outVars.length) {
-      const selectOut = outVars.map(({ variable, name }) => `${variable} AS ${this.quoteIdentifier(name)}`).join(", ");
-      statements.push(`SELECT ${selectOut};`);
+    if (!clause.action.set.length) {
+      throw new Error("MySQL ON DUPLICATE KEY UPDATE requires at least one assignment.");
     }
-    return {
-      sql: statements.join(" "),
-      params: [...ctx.params],
-      outParams: {
-        source: outVars.length ? "lastResultSet" : "none",
-        names: outVars.map((item) => item.name)
+    const assignments = clause.action.set.map((assignment) => {
+      const target = services.quoteIdentifier(assignment.column.name);
+      const value = services.compileOperand(assignment.value, ctx);
+      return `${target} = ${value}`;
+    }).join(", ");
+    return ` ON DUPLICATE KEY UPDATE ${assignments}`;
+  }
+};
+
+// src/core/dialect/mysql/index.ts
+var MySqlDialect = class extends SqlDialectBase {
+  dialect = "mysql";
+  procedureCompiler;
+  constructor() {
+    super({
+      functionStrategy: new MysqlFunctionStrategy(),
+      upsertStrategy: new MySqlUpsertStrategy()
+    });
+    this.procedureCompiler = new MySqlProcedureCompiler({
+      quoteIdentifier: (id) => this.quoteIdentifier(id),
+      createCompilerContext: () => this.createCompilerContext(),
+      compileOperand: (node, ctx) => this.compileOperand(node, ctx)
+    });
+    this.registerExpressionCompiler(
+      "IsDistinctExpression",
+      (node, ctx) => {
+        const left2 = this.compileOperand(node.left, ctx);
+        const right2 = this.compileOperand(node.right, ctx);
+        const spaceship = `${left2} <=> ${right2}`;
+        return node.operator === "IS NOT DISTINCT FROM" ? spaceship : `NOT (${spaceship})`;
       }
-    };
+    );
+  }
+  quoteIdentifier(id) {
+    return `\`${id}\``;
+  }
+  compileJsonPath(node) {
+    const column = `${this.quoteIdentifier(node.column.table)}.${this.quoteIdentifier(node.column.name)}`;
+    return `${column}->'${node.path}'`;
+  }
+  compileProcedureCall(ast) {
+    return this.procedureCompiler.compileProcedureCall(ast);
   }
 };
 
@@ -2690,14 +2846,56 @@ var SqliteFunctionStrategy = class extends StandardFunctionStrategy {
   }
 };
 
+// src/core/dialect/sqlite/returning.ts
+var SqliteReturningStrategy = class {
+  compileReturning(returning, _ctx, quoteIdentifier) {
+    void _ctx;
+    if (!returning || returning.length === 0) return "";
+    return ` RETURNING ${this.formatReturningColumns(returning, quoteIdentifier)}`;
+  }
+  formatReturningColumns(returning, quoteIdentifier) {
+    return returning.map((column) => {
+      const alias = column.alias ? ` AS ${quoteIdentifier(column.alias)}` : "";
+      return `${quoteIdentifier(column.name)}${alias}`;
+    }).join(", ");
+  }
+};
+
+// src/core/dialect/sqlite/upsert.ts
+var SqliteUpsertStrategy = class {
+  compile(ast, ctx, services) {
+    if (!ast.onConflict) return "";
+    const clause = ast.onConflict;
+    if (clause.target.constraint) {
+      throw new Error("SQLite ON CONFLICT does not support named constraints.");
+    }
+    if (!clause.target.columns.length) {
+      throw new Error("SQLite ON CONFLICT requires conflict columns.");
+    }
+    const columns = clause.target.columns.map((column) => services.quoteIdentifier(column.name)).join(", ");
+    const target = ` ON CONFLICT (${columns})`;
+    if (clause.action.type === "DoNothing") {
+      return `${target} DO NOTHING`;
+    }
+    if (!clause.action.set.length) {
+      throw new Error("SQLite ON CONFLICT DO UPDATE requires at least one assignment.");
+    }
+    const assignments = services.compileUpdateAssignments(clause.action.set, ast.into, ctx);
+    const where = clause.action.where ? ` WHERE ${services.compileExpression(clause.action.where, ctx)}` : "";
+    return `${target} DO UPDATE SET ${assignments}${where}`;
+  }
+};
+
 // src/core/dialect/sqlite/index.ts
 var SqliteDialect = class extends SqlDialectBase {
   dialect = "sqlite";
-  /**
-   * Creates a new SqliteDialect instance
-   */
   constructor() {
-    super(new SqliteFunctionStrategy());
+    super({
+      functionStrategy: new SqliteFunctionStrategy(),
+      returningStrategy: new SqliteReturningStrategy(),
+      upsertStrategy: new SqliteUpsertStrategy(),
+      supportsDmlReturning: true
+    });
     this.registerExpressionCompiler("BitwiseExpression", (node, ctx) => {
       const left2 = this.compileOperand(node.left, ctx);
       const right2 = this.compileOperand(node.right, ctx);
@@ -2715,61 +2913,17 @@ var SqliteDialect = class extends SqlDialectBase {
       return `(${left2} ${node.operator} ${right2})`;
     });
   }
-  /**
-   * Quotes an identifier using SQLite double-quote syntax
-   * @param id - Identifier to quote
-   * @returns Quoted identifier
-   */
   quoteIdentifier(id) {
     return `"${id}"`;
   }
-  /**
-   * Compiles JSON path expression using SQLite syntax
-   * @param node - JSON path node
-   * @returns SQLite JSON path expression
-   */
   compileJsonPath(node) {
-    const col2 = `${this.quoteIdentifier(node.column.table)}.${this.quoteIdentifier(node.column.name)}`;
-    return `json_extract(${col2}, '${node.path}')`;
+    const column = `${this.quoteIdentifier(node.column.table)}.${this.quoteIdentifier(node.column.name)}`;
+    return `json_extract(${column}, '${node.path}')`;
   }
   compileQualifiedColumn(column, _table) {
     void _table;
     return this.quoteIdentifier(column.name);
   }
-  compileReturning(returning, ctx) {
-    void ctx;
-    if (!returning || returning.length === 0) return "";
-    const columns = this.formatReturningColumns(returning);
-    return ` RETURNING ${columns}`;
-  }
-  formatReturningColumns(returning) {
-    return returning.map((column) => {
-      const alias = column.alias ? ` AS ${this.quoteIdentifier(column.alias)}` : "";
-      return `${this.quoteIdentifier(column.name)}${alias}`;
-    }).join(", ");
-  }
-  compileUpsertClause(ast, ctx) {
-    if (!ast.onConflict) return "";
-    const clause = ast.onConflict;
-    if (clause.target.constraint) {
-      throw new Error("SQLite ON CONFLICT does not support named constraints.");
-    }
-    this.ensureConflictColumns(clause, "SQLite ON CONFLICT requires conflict columns.");
-    const cols = clause.target.columns.map((col2) => this.quoteIdentifier(col2.name)).join(", ");
-    const target = ` ON CONFLICT (${cols})`;
-    if (clause.action.type === "DoNothing") {
-      return `${target} DO NOTHING`;
-    }
-    if (!clause.action.set.length) {
-      throw new Error("SQLite ON CONFLICT DO UPDATE requires at least one assignment.");
-    }
-    const assignments = this.compileUpdateAssignments(clause.action.set, ast.into, ctx);
-    const where = clause.action.where ? ` WHERE ${this.compileExpression(clause.action.where, ctx)}` : "";
-    return `${target} DO UPDATE SET ${assignments}${where}`;
-  }
-  supportsDmlReturningClause() {
-    return true;
-  }
 };
 
 // src/core/dialect/mssql/functions.ts
@@ -2896,202 +3050,107 @@ var MssqlFunctionStrategy = class extends StandardFunctionStrategy {
   }
 };
 
-// src/core/dialect/mssql/index.ts
-var sanitizeVariableSuffix2 = (value) => value.replace(/[^a-zA-Z0-9_]/g, "_");
-var toProcedureParamReference = (value) => value.startsWith("@") ? value : `@${value}`;
-var SqlServerDialect = class extends SqlDialectBase {
-  dialect = "mssql";
-  /**
-   * Creates a new SqlServerDialect instance
-   */
-  constructor() {
-    super(new MssqlFunctionStrategy());
-  }
-  /**
-   * Quotes an identifier using SQL Server bracket syntax
-   * @param id - Identifier to quote
-   * @returns Quoted identifier
-   */
-  quoteIdentifier(id) {
-    return `[${id}]`;
-  }
-  /**
-   * Compiles JSON path expression using SQL Server syntax
-   * @param node - JSON path node
-   * @returns SQL Server JSON path expression
-   */
-  compileJsonPath(node) {
-    const col2 = `${this.quoteIdentifier(node.column.table)}.${this.quoteIdentifier(node.column.name)}`;
-    return `JSON_VALUE(${col2}, '${node.path}')`;
+// src/core/dialect/mssql/output.ts
+var MssqlOutputStrategy = class {
+  compileReturning(returning, _ctx, quoteIdentifier) {
+    void _ctx;
+    return this.compileOutput(returning, "inserted", quoteIdentifier);
   }
-  /**
-   * Formats parameter placeholders using SQL Server named parameter syntax
-   * @param index - Parameter index
-   * @returns Named parameter placeholder
-   */
-  formatPlaceholder(index) {
-    return `@p${index}`;
+  compileOutput(returning, prefix, quoteIdentifier) {
+    if (!returning || returning.length === 0) return "";
+    const columns = returning.map((column) => {
+      const alias = column.alias ? ` AS ${quoteIdentifier(column.alias)}` : "";
+      return `${prefix}.${quoteIdentifier(column.name)}${alias}`;
+    }).join(", ");
+    return ` OUTPUT ${columns}`;
   }
-  /**
-   * Compiles SELECT query AST to SQL Server SQL
-   * @param ast - Query AST
-   * @param ctx - Compiler context
-   * @returns SQL Server SQL string
-   */
-  compileSelectAst(ast, ctx) {
-    const hasSetOps = !!(ast.setOps && ast.setOps.length);
-    const ctes = this.compileCtes(ast, ctx);
-    const baseAst = hasSetOps ? { ...ast, setOps: void 0, orderBy: void 0, limit: void 0, offset: void 0 } : ast;
-    const baseSelect = this.compileSelectCoreForMssql(baseAst, ctx);
-    if (!hasSetOps) {
-      return `${ctes}${baseSelect}`;
-    }
-    const compound = ast.setOps.map((op) => `${op.operator} ${this.wrapSetOperand(this.compileSelectAst(op.query, ctx))}`).join(" ");
-    const orderBy = this.compileOrderBy(ast, ctx);
-    const pagination = this.compilePagination(ast, orderBy);
-    const combined = `${this.wrapSetOperand(baseSelect)} ${compound}`;
-    const tail = pagination || orderBy;
-    return `${ctes}${combined}${tail}`;
+  formatReturningColumns(returning, quoteIdentifier) {
+    return returning.map((column) => {
+      const alias = column.alias ? ` AS ${quoteIdentifier(column.alias)}` : "";
+      return `${quoteIdentifier(column.name)}${alias}`;
+    }).join(", ");
   }
-  compileDeleteAst(ast, ctx) {
+};
+
+// src/core/dialect/mssql/delete-compiler.ts
+var MssqlDeleteCompiler = class {
+  constructor(services, sources) {
+    this.services = services;
+    this.sources = sources;
+  }
+  output = new MssqlOutputStrategy();
+  compile(ast, ctx) {
     if (ast.using) {
       throw new Error("DELETE ... USING is not supported in the MSSQL dialect; use join() instead.");
     }
-    if (ast.from.type !== "Table") {
-      throw new Error("DELETE only supports base tables in the MSSQL dialect.");
-    }
     const alias = ast.from.alias ?? ast.from.name;
-    const target = this.compileTableReference(ast.from);
+    const target = this.sources.compileTableReference(ast.from);
     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 returning = this.compileOutputClause(ast.returning, "deleted");
-    return `DELETE ${this.quoteIdentifier(alias)}${returning} FROM ${target}${joins}${whereClause}`;
-  }
-  compileUpdateAst(ast, ctx) {
-    const target = this.compileTableReference(ast.table);
-    const assignments = this.compileUpdateAssignments(ast.set, ast.table, ctx);
-    const output = this.compileReturning(ast.returning, ctx);
-    const fromClause = ast.from ? ` FROM ${this.compileFrom(ast.from, ctx)}` : "";
-    const joins = ast.joins ? ast.joins.map((j) => {
-      const table = this.compileFrom(j.table, ctx);
-      const cond = this.compileExpression(j.condition, ctx);
-      return ` ${j.kind} JOIN ${table} ON ${cond}`;
-    }).join("") : "";
-    const whereClause = this.compileWhere(ast.where, ctx);
-    return `UPDATE ${target} SET ${assignments}${output}${fromClause}${joins}${whereClause}`;
-  }
-  compileSelectCoreForMssql(ast, ctx) {
-    const columns = ast.columns.map((c) => {
-      const expr = c.type === "Column" ? `${this.quoteIdentifier(c.table)}.${this.quoteIdentifier(c.name)}` : this.compileOperand(c, ctx);
-      if (c.alias) {
-        if (c.alias.includes("(")) return c.alias;
-        return `${expr} AS ${this.quoteIdentifier(c.alias)}`;
-      }
-      return expr;
-    }).join(", ");
-    const distinct = ast.distinct ? "DISTINCT " : "";
-    const from = this.compileFrom(ast.from, ctx);
-    const joins = ast.joins.map((j) => {
-      const table = this.compileFrom(j.table, ctx);
-      const cond = this.compileExpression(j.condition, ctx);
-      return `${j.kind} JOIN ${table} ON ${cond}`;
-    }).join(" ");
-    const whereClause = this.compileWhere(ast.where, ctx);
-    const groupBy = ast.groupBy && ast.groupBy.length > 0 ? " GROUP BY " + ast.groupBy.map((term) => this.compileOrderingTerm(term, ctx)).join(", ") : "";
-    const having = ast.having ? ` HAVING ${this.compileExpression(ast.having, ctx)}` : "";
-    const orderBy = this.compileOrderBy(ast, ctx);
-    const pagination = this.compilePagination(ast, orderBy);
-    if (pagination) {
-      return `SELECT ${distinct}${columns} FROM ${from}${joins ? " " + joins : ""}${whereClause}${groupBy}${having}${pagination}`;
-    }
-    return `SELECT ${distinct}${columns} FROM ${from}${joins ? " " + joins : ""}${whereClause}${groupBy}${having}${orderBy}`;
-  }
-  compileOrderBy(ast, ctx) {
-    return OrderByCompiler.compileOrderBy(
-      ast,
-      (term) => this.compileOrderingTerm(term, ctx),
-      this.renderOrderByNulls.bind(this),
-      this.renderOrderByCollation.bind(this)
+    const where = ast.where ? ` WHERE ${this.services.compileExpression(ast.where, ctx)}` : "";
+    const returning = this.output.compileOutput(
+      ast.returning,
+      "deleted",
+      (id) => this.services.quoteIdentifier(id)
     );
+    return `DELETE ${this.services.quoteIdentifier(alias)}${returning} FROM ${target}${joins}${where}`;
   }
-  compilePagination(ast, orderBy) {
-    const hasLimit = ast.limit !== void 0;
-    const hasOffset = ast.offset !== void 0;
-    if (!hasLimit && !hasOffset) return "";
-    const off = ast.offset ?? 0;
-    let orderClause = orderBy;
-    if (!orderClause) {
-      orderClause = ast.distinct && ast.distinct.length > 0 ? " ORDER BY 1" : " ORDER BY (SELECT NULL)";
-    }
-    let pagination = `${orderClause} OFFSET ${off} ROWS`;
-    if (hasLimit) {
-      pagination += ` FETCH NEXT ${ast.limit} ROWS ONLY`;
-    }
-    return pagination;
-  }
-  supportsDmlReturningClause() {
-    return true;
-  }
-  compileReturning(returning, _ctx) {
-    void _ctx;
-    return this.compileOutputClause(returning, "inserted");
-  }
-  compileOutputClause(returning, prefix) {
-    if (!returning || returning.length === 0) return "";
-    const columns = returning.map((column) => {
-      const colName = this.quoteIdentifier(column.name);
-      const alias = column.alias ? ` AS ${this.quoteIdentifier(column.alias)}` : "";
-      return `${prefix}.${colName}${alias}`;
-    }).join(", ");
-    return ` OUTPUT ${columns}`;
+};
+
+// src/core/dialect/mssql/insert-compiler.ts
+var MssqlInsertCompiler = class {
+  constructor(services, sources) {
+    this.services = services;
+    this.sources = sources;
   }
-  compileInsertAst(ast, ctx) {
+  compile(ast, ctx) {
     if (!ast.columns.length) {
       throw new Error("INSERT queries must specify columns.");
     }
-    if (ast.onConflict) {
-      return this.compileMergeInsert(ast, ctx);
-    }
-    const table = this.compileTableName(ast.into);
-    const columnList = ast.columns.map((column) => this.quoteIdentifier(column.name)).join(", ");
-    const output = this.compileReturning(ast.returning, ctx);
-    const source = this.compileInsertValues(ast, ctx);
-    return `INSERT INTO ${table} (${columnList})${output} ${source}`;
+    if (ast.onConflict) return this.compileMerge(ast, ctx);
+    const table = this.sources.compileTableName(ast.into);
+    const columns = ast.columns.map((column) => this.services.quoteIdentifier(column.name)).join(", ");
+    const output = this.services.compileReturning(ast.returning, ctx);
+    const source = this.compileInsertSource(ast, ctx);
+    return `INSERT INTO ${table} (${columns})${output} ${source}`;
   }
-  compileMergeInsert(ast, ctx) {
+  compileMerge(ast, ctx) {
     const clause = ast.onConflict;
     if (clause.target.constraint) {
       throw new Error("MSSQL MERGE does not support conflict target by constraint name.");
     }
-    this.ensureConflictColumns(clause, "MSSQL MERGE requires conflict columns for the ON clause.");
-    const table = this.compileTableName(ast.into);
-    const targetRef = this.quoteIdentifier(ast.into.alias ?? ast.into.name);
-    const sourceAlias = this.quoteIdentifier("src");
-    const sourceColumns = ast.columns.map((column) => this.quoteIdentifier(column.name)).join(", ");
+    if (!clause.target.columns.length) {
+      throw new Error("MSSQL MERGE requires conflict columns for the ON clause.");
+    }
+    const table = this.sources.compileTableName(ast.into);
+    const targetRef = this.services.quoteIdentifier(ast.into.alias ?? ast.into.name);
+    const sourceAlias = this.services.quoteIdentifier("src");
+    const sourceColumns = ast.columns.map((column) => this.services.quoteIdentifier(column.name)).join(", ");
     const usingSource = this.compileMergeUsingSource(ast, ctx);
-    const onClause = clause.target.columns.map((column) => `${targetRef}.${this.quoteIdentifier(column.name)} = ${sourceAlias}.${this.quoteIdentifier(column.name)}`).join(" AND ");
+    const onClause = clause.target.columns.map(
+      (column) => `${targetRef}.${this.services.quoteIdentifier(column.name)} = ${sourceAlias}.${this.services.quoteIdentifier(column.name)}`
+    ).join(" AND ");
     const branches = [];
     if (clause.action.type === "DoUpdate") {
       if (!clause.action.set.length) {
         throw new Error("MSSQL MERGE WHEN MATCHED UPDATE requires at least one assignment.");
       }
       const assignments = clause.action.set.map((assignment) => {
-        const target = `${targetRef}.${this.quoteIdentifier(assignment.column.name)}`;
-        const value = this.compileOperand(assignment.value, ctx);
+        const target = `${targetRef}.${this.services.quoteIdentifier(assignment.column.name)}`;
+        const value = this.services.compileOperand(assignment.value, ctx);
         return `${target} = ${value}`;
       }).join(", ");
-      const guard = clause.action.where ? ` AND ${this.compileExpression(clause.action.where, ctx)}` : "";
+      const guard = clause.action.where ? ` AND ${this.services.compileExpression(clause.action.where, ctx)}` : "";
       branches.push(`WHEN MATCHED${guard} THEN UPDATE SET ${assignments}`);
     }
-    const insertColumns = ast.columns.map((column) => this.quoteIdentifier(column.name)).join(", ");
-    const insertValues = ast.columns.map((column) => `${sourceAlias}.${this.quoteIdentifier(column.name)}`).join(", ");
+    const insertColumns = ast.columns.map((column) => this.services.quoteIdentifier(column.name)).join(", ");
+    const insertValues = ast.columns.map((column) => `${sourceAlias}.${this.services.quoteIdentifier(column.name)}`).join(", ");
     branches.push(`WHEN NOT MATCHED THEN INSERT (${insertColumns}) VALUES (${insertValues})`);
-    const output = this.compileReturning(ast.returning, ctx);
+    const output = this.services.compileReturning(ast.returning, ctx);
     return `MERGE INTO ${table} USING ${usingSource} AS ${sourceAlias} (${sourceColumns}) ON ${onClause} ${branches.join(" ")}${output}`;
   }
   compileMergeUsingSource(ast, ctx) {
@@ -3099,38 +3158,146 @@ var SqlServerDialect = class extends SqlDialectBase {
       if (!ast.source.rows.length) {
         throw new Error("INSERT ... VALUES requires at least one row.");
       }
-      const rows = ast.source.rows.map((row) => `(${row.map((value) => this.compileOperand(value, ctx)).join(", ")})`).join(", ");
+      const rows = ast.source.rows.map((row) => `(${row.map((value) => this.services.compileOperand(value, ctx)).join(", ")})`).join(", ");
       return `(VALUES ${rows})`;
     }
-    const normalized = this.normalizeSelectAst(ast.source.query);
-    const selectSql = this.compileSelectAst(normalized, ctx).trim().replace(/;$/, "");
+    const normalized = this.services.normalizeSelectAst(ast.source.query);
+    const selectSql = this.sources.stripTrailingSemicolon(
+      this.services.compileSelectAst(normalized, ctx)
+    );
     return `(${selectSql})`;
   }
-  compileInsertValues(ast, ctx) {
-    const source = ast.source;
-    if (source.type === "InsertValues") {
-      if (!source.rows.length) {
+  compileInsertSource(ast, ctx) {
+    if (ast.source.type === "InsertValues") {
+      if (!ast.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 = ast.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(ast.source.query);
+    return this.services.compileSelectAst(normalized, ctx).trim();
+  }
+};
+
+// src/core/dialect/mssql/select-compiler.ts
+var MssqlSelectCompiler = class {
+  constructor(services, sources) {
+    this.services = services;
+    this.sources = sources;
+  }
+  compile(ast, ctx) {
+    const hasSetOps = !!(ast.setOps && ast.setOps.length);
+    const ctes = this.compileCtes(ast, ctx);
+    const baseAst = hasSetOps ? { ...ast, setOps: void 0, orderBy: void 0, limit: void 0, offset: void 0 } : ast;
+    const baseSelect = this.compileCore(baseAst, ctx);
+    if (!hasSetOps) return `${ctes}${baseSelect}`;
+    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.compilePagination(ast, orderBy);
+    const combined = `${this.sources.wrapSetOperand(baseSelect)} ${compound}`;
+    return `${ctes}${combined}${pagination || orderBy}`;
+  }
+  compileCore(ast, ctx) {
+    const columns = ast.columns.map((column) => {
+      const expr = column.type === "Column" ? `${this.services.quoteIdentifier(column.table)}.${this.services.quoteIdentifier(column.name)}` : 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(", ");
+    const distinct = ast.distinct ? "DISTINCT " : "";
+    const from = this.sources.compileFrom(ast.from, ctx);
+    const joins = ast.joins.map((join) => {
+      const table = this.sources.compileFrom(join.table, ctx);
+      const condition = this.services.compileExpression(join.condition, ctx);
+      return `${join.kind} JOIN ${table} ON ${condition}`;
+    }).join(" ");
+    const where = ast.where ? ` WHERE ${this.services.compileExpression(ast.where, ctx)}` : "";
+    const groupBy = ast.groupBy && ast.groupBy.length > 0 ? ` GROUP BY ${ast.groupBy.map((term) => this.services.compileOrderingTerm(term, ctx)).join(", ")}` : "";
+    const having = ast.having ? ` HAVING ${this.services.compileExpression(ast.having, ctx)}` : "";
+    const orderBy = this.compileOrderBy(ast, ctx);
+    const pagination = this.compilePagination(ast, orderBy);
+    if (pagination) {
+      return `SELECT ${distinct}${columns} FROM ${from}${joins ? ` ${joins}` : ""}${where}${groupBy}${having}${pagination}`;
+    }
+    return `SELECT ${distinct}${columns} FROM ${from}${joins ? ` ${joins}` : ""}${where}${groupBy}${having}${orderBy}`;
+  }
+  compileOrderBy(ast, ctx) {
+    return OrderByCompiler.compileOrderBy(
+      ast,
+      (term) => this.services.compileOrderingTerm(term, ctx),
+      (order) => this.services.renderOrderByNulls(order),
+      (order) => this.services.renderOrderByCollation(order)
+    );
+  }
+  compilePagination(ast, orderBy) {
+    const hasLimit = ast.limit !== void 0;
+    const hasOffset = ast.offset !== void 0;
+    if (!hasLimit && !hasOffset) return "";
+    const offset = ast.offset ?? 0;
+    let orderClause = orderBy;
+    if (!orderClause) {
+      orderClause = ast.distinct && ast.distinct.length > 0 ? " ORDER BY 1" : " ORDER BY (SELECT NULL)";
+    }
+    let pagination = `${orderClause} OFFSET ${offset} ROWS`;
+    if (hasLimit) pagination += ` FETCH NEXT ${ast.limit} ROWS ONLY`;
+    return pagination;
   }
   compileCtes(ast, ctx) {
     if (!ast.ctes || ast.ctes.length === 0) return "";
-    const defs = ast.ctes.map((cte) => {
-      const name = this.quoteIdentifier(cte.name);
-      const cols = cte.columns ? `(${cte.columns.map((c) => this.quoteIdentifier(c)).join(", ")})` : "";
-      const query = this.compileSelectAst(this.normalizeSelectAst(cte.query), ctx).trim().replace(/;$/, "");
-      return `${name}${cols} AS (${query})`;
+    const definitions = ast.ctes.map((cte) => {
+      const name = this.services.quoteIdentifier(cte.name);
+      const columns = cte.columns ? `(${cte.columns.map((column) => this.services.quoteIdentifier(column)).join(", ")})` : "";
+      const query = this.sources.stripTrailingSemicolon(
+        this.services.compileSelectAst(this.services.normalizeSelectAst(cte.query), ctx)
+      );
+      return `${name}${columns} AS (${query})`;
     }).join(", ");
-    return `WITH ${defs} `;
+    return `WITH ${definitions} `;
+  }
+};
+
+// src/core/dialect/mssql/update-compiler.ts
+var MssqlUpdateCompiler = class {
+  constructor(services, sources) {
+    this.services = services;
+    this.sources = sources;
+    this.standardUpdate = new StandardUpdateCompiler(services, sources);
+  }
+  standardUpdate;
+  compile(ast, ctx) {
+    const target = this.sources.compileTableReference(ast.table);
+    const assignments = this.standardUpdate.compileAssignments(ast.set, ast.table, ctx);
+    const output = this.services.compileReturning(ast.returning, ctx);
+    const from = ast.from ? ` FROM ${this.sources.compileFrom(ast.from, ctx)}` : "";
+    const joins = ast.joins ? ast.joins.map((join) => {
+      const table = this.sources.compileFrom(join.table, ctx);
+      const condition = this.services.compileExpression(join.condition, ctx);
+      return ` ${join.kind} JOIN ${table} ON ${condition}`;
+    }).join("") : "";
+    const where = ast.where ? ` WHERE ${this.services.compileExpression(ast.where, ctx)}` : "";
+    return `UPDATE ${target} SET ${assignments}${output}${from}${joins}${where}`;
+  }
+};
+
+// src/core/dialect/mssql/compiler-factory.ts
+var createMssqlCompilerSet = ({ services, sources }) => ({
+  select: new MssqlSelectCompiler(services, sources),
+  insert: new MssqlInsertCompiler(services, sources),
+  update: new MssqlUpdateCompiler(services, sources),
+  delete: new MssqlDeleteCompiler(services, sources)
+});
+
+// src/core/dialect/mssql/procedure-compiler.ts
+var sanitizeVariableSuffix2 = (value) => value.replace(/[^a-zA-Z0-9_]/g, "_");
+var toProcedureParamReference = (value) => value.startsWith("@") ? value : `@${value}`;
+var MssqlProcedureCompiler = class {
+  constructor(services) {
+    this.services = services;
   }
   compileProcedureCall(ast) {
-    const ctx = this.createCompilerContext();
-    const qualifiedName = ast.ref.schema ? `${this.quoteIdentifier(ast.ref.schema)}.${this.quoteIdentifier(ast.ref.name)}` : this.quoteIdentifier(ast.ref.name);
+    const ctx = this.services.createCompilerContext();
+    const qualifiedName = ast.ref.schema ? `${this.services.quoteIdentifier(ast.ref.schema)}.${this.services.quoteIdentifier(ast.ref.name)}` : this.services.quoteIdentifier(ast.ref.name);
     const declarations = [];
     const assignments = [];
     const execArgs = [];
@@ -3141,7 +3308,7 @@ var SqlServerDialect = class extends SqlDialectBase {
         if (!param.value) {
           throw new Error(`Procedure parameter "${param.name}" requires a value for direction "in".`);
         }
-        execArgs.push(`${targetParam} = ${this.compileOperand(param.value, ctx)}`);
+        execArgs.push(`${targetParam} = ${this.services.compileOperand(param.value, ctx)}`);
         return;
       }
       if (!param.dbType) {
@@ -3156,7 +3323,7 @@ var SqlServerDialect = class extends SqlDialectBase {
         if (!param.value) {
           throw new Error(`Procedure parameter "${param.name}" requires a value for direction "inout".`);
         }
-        assignments.push(`SET ${variable} = ${this.compileOperand(param.value, ctx)};`);
+        assignments.push(`SET ${variable} = ${this.services.compileOperand(param.value, ctx)};`);
       }
       execArgs.push(`${targetParam} = ${variable} OUTPUT`);
       outVars.push({ variable, name: param.name });
@@ -3167,7 +3334,7 @@ var SqlServerDialect = class extends SqlDialectBase {
     const argsSql = execArgs.length ? ` ${execArgs.join(", ")}` : "";
     statements.push(`EXEC ${qualifiedName}${argsSql};`);
     if (outVars.length) {
-      const selectOut = outVars.map(({ variable, name }) => `${variable} AS ${this.quoteIdentifier(name)}`).join(", ");
+      const selectOut = outVars.map(({ variable, name }) => `${variable} AS ${this.services.quoteIdentifier(name)}`).join(", ");
       statements.push(`SELECT ${selectOut};`);
     }
     return {
@@ -3181,6 +3348,38 @@ var SqlServerDialect = class extends SqlDialectBase {
   }
 };
 
+// src/core/dialect/mssql/index.ts
+var SqlServerDialect = class extends SqlDialectBase {
+  dialect = "mssql";
+  procedureCompiler;
+  constructor() {
+    super({
+      functionStrategy: new MssqlFunctionStrategy(),
+      returningStrategy: new MssqlOutputStrategy(),
+      compilerFactory: createMssqlCompilerSet,
+      supportsDmlReturning: true
+    });
+    this.procedureCompiler = new MssqlProcedureCompiler({
+      quoteIdentifier: (id) => this.quoteIdentifier(id),
+      createCompilerContext: () => this.createCompilerContext(),
+      compileOperand: (node, ctx) => this.compileOperand(node, ctx)
+    });
+  }
+  quoteIdentifier(id) {
+    return `[${id}]`;
+  }
+  compileJsonPath(node) {
+    const column = `${this.quoteIdentifier(node.column.table)}.${this.quoteIdentifier(node.column.name)}`;
+    return `JSON_VALUE(${column}, '${node.path}')`;
+  }
+  formatPlaceholder(index) {
+    return `@p${index}`;
+  }
+  compileProcedureCall(ast) {
+    return this.procedureCompiler.compileProcedureCall(ast);
+  }
+};
+
 // src/core/dialect/dialect-factory.ts
 var DialectFactory = class {
   static registry = /* @__PURE__ */ new Map();
@@ -21658,13 +21857,26 @@ export {
   MorphMany,
   MorphOne,
   MorphTo,
+  MssqlDeleteCompiler,
+  MssqlInsertCompiler,
+  MssqlOutputStrategy,
+  MssqlProcedureCompiler,
+  MssqlSelectCompiler,
+  MssqlUpdateCompiler,
   MySqlDialect,
+  MySqlProcedureCompiler,
+  MySqlUpsertStrategy,
   NestedSetStrategy,
+  NoReturningStrategy,
+  NoUpsertStrategy,
   Orm,
   OrmSession,
   Pattern,
   Pool,
   PostgresDialect,
+  PostgresProcedureCompiler,
+  PostgresReturningStrategy,
+  PostgresUpsertStrategy,
   PrimaryKey,
   ProcedureCallBuilder,
   PrototypeMaterializationStrategy,
@@ -21673,8 +21885,19 @@ export {
   RelationKinds,
   STANDARD_COLUMN_TYPES,
   SelectQueryBuilder,
+  SqlDialectBase,
   SqlServerDialect,
   SqliteDialect,
+  SqliteReturningStrategy,
+  SqliteUpsertStrategy,
+  StandardDeleteCompiler,
+  StandardInsertCompiler,
+  StandardLimitOffsetPagination,
+  StandardReturningStrategy,
+  StandardSelectCompiler,
+  StandardSqlSourceCompiler,
+  StandardTableFunctionStrategy,
+  StandardUpdateCompiler,
   StringTypeStrategy,
   TagIndex,
   Title,
@@ -21761,6 +21984,7 @@ export {
   createEntityFromRow,
   createEntityProxy,
   createExecutorFromQueryRunner,
+  createMssqlCompilerSet,
   createMssqlExecutor,
   createMysqlExecutor,
   createPooledExecutorFactory,