metal-orm 1.1.23 → 1.1.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metal-orm",
-  "version": "1.1.23",
+  "version": "1.1.25",
   "type": "module",
   "repository": {
     "type": "git",

package/src/core/dialect/base/returning-strategy.ts

@@ -1,51 +1,39 @@
-import { ColumnNode } from '../../ast/expression.js';
-import { CompilerContext } from '../abstract.js';
+import type { ColumnNode } from '../../ast/expression.js';
+import type { CompilerContext } from '../abstract.js';
 
-/**
- * Strategy interface for handling RETURNING clauses in DML statements (INSERT, UPDATE, DELETE).
- * Different SQL dialects have varying levels of support for RETURNING clauses.
- */
+export type QuoteIdentifier = (id: string) => string;
+
+/** Backend-specific RETURNING/OUTPUT rendering strategy. */
 export interface ReturningStrategy {
-  /**
-   * Compiles a RETURNING clause for DML statements.
-   * @param returning - Array of columns to return, or undefined if none.
-   * @param ctx - The compiler context for expression compilation.
-   * @returns SQL RETURNING clause or empty string if not supported.
-   * @throws Error if RETURNING is not supported by this dialect.
-   */
-  compileReturning(returning: ColumnNode[] | undefined, ctx: CompilerContext): string;
-  /**
-   * Formats column list for RETURNING clause.
-   * @param returning - Array of columns to format.
-   * @param quoteIdentifier - Function to quote identifiers according to dialect rules.
-   * @returns Formatted column list (e.g., "table.col1, table.col2").
-   */
-  formatReturningColumns(returning: ColumnNode[], quoteIdentifier: (id: string) => string): string;
+  compileReturning(
+    returning: ColumnNode[] | undefined,
+    ctx: CompilerContext,
+    quoteIdentifier: QuoteIdentifier
+  ): string;
+
+  formatReturningColumns(
+    returning: ColumnNode[],
+    quoteIdentifier: QuoteIdentifier
+  ): string;
 }
 
-/**
- * Default RETURNING strategy that throws an error when RETURNING is used.
- * Use this for dialects that don't support RETURNING clauses.
- */
+/** Default RETURNING strategy for dialects without support. */
 export class NoReturningStrategy implements ReturningStrategy {
-  /**
-   * 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: ColumnNode[] | undefined, _ctx: CompilerContext): string {
+  compileReturning(
+    returning: ColumnNode[] | undefined,
+    _ctx: CompilerContext,
+    _quoteIdentifier: QuoteIdentifier
+  ): string {
     void _ctx;
+    void _quoteIdentifier;
     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: ColumnNode[], quoteIdentifier: (id: string) => string): string {
+
+  formatReturningColumns(
+    returning: ColumnNode[],
+    quoteIdentifier: QuoteIdentifier
+  ): string {
     return returning
       .map(column => {
         const tablePart = column.table ? `${quoteIdentifier(column.table)}.` : '';
@@ -55,3 +43,16 @@ export class NoReturningStrategy implements ReturningStrategy {
       .join(', ');
   }
 }
+
+/** Standard SQL RETURNING implementation with qualified column support. */
+export class StandardReturningStrategy extends NoReturningStrategy {
+  override compileReturning(
+    returning: ColumnNode[] | undefined,
+    _ctx: CompilerContext,
+    quoteIdentifier: QuoteIdentifier
+  ): string {
+    void _ctx;
+    if (!returning || returning.length === 0) return '';
+    return ` RETURNING ${this.formatReturningColumns(returning, quoteIdentifier)}`;
+  }
+}

package/src/core/dialect/base/sql-compiler-set.ts

@@ -0,0 +1,33 @@
+import type { CompilerContext } from '../abstract.js';
+import type {
+  DeleteQueryNode,
+  InsertQueryNode,
+  SelectQueryNode,
+  UpdateQueryNode
+} from '../../ast/query.js';
+import type { StandardSqlCompilerServices } from './standard-sql-services.js';
+import type { StandardSqlSourceCompiler } from './standard-sql-source-compiler.js';
+
+export interface SqlAstCompiler<TAst> {
+  compile(ast: TAst, ctx: CompilerContext): string;
+}
+
+export interface SqlCompilerSet {
+  select: SqlAstCompiler<SelectQueryNode>;
+  insert: SqlAstCompiler<InsertQueryNode>;
+  update: SqlAstCompiler<UpdateQueryNode>;
+  delete: SqlAstCompiler<DeleteQueryNode>;
+}
+
+export interface SqlCompilerAssemblyContext {
+  services: StandardSqlCompilerServices;
+  sources: StandardSqlSourceCompiler;
+}
+
+/**
+ * Allows a backend to replace only the standard query compilers whose SQL
+ * grammar genuinely differs from the common implementation.
+ */
+export type SqlCompilerFactory = (
+  context: SqlCompilerAssemblyContext
+) => Partial<SqlCompilerSet>;

package/src/core/dialect/base/sql-dialect.ts

@@ -1,166 +1,157 @@
 import { DialectBase } from '../abstract.js';
 import type { CompilerContext } from '../abstract.js';
 import type {
-  SelectQueryNode,
-  InsertQueryNode,
-  UpdateQueryNode,
   DeleteQueryNode,
-  InsertSourceNode,
-  UpsertClause,
-  TableSourceNode,
   DerivedTableNode,
   FunctionTableNode,
+  InsertQueryNode,
   OrderByNode,
-  TableNode
+  SelectQueryNode,
+  TableNode,
+  TableSourceNode,
+  UpdateAssignmentNode,
+  UpdateQueryNode,
+  UpsertClause
 } from '../../ast/query.js';
-import type { ColumnNode, OperandNode } from '../../ast/expression.js';
-import { FunctionTableFormatter } from './function-table-formatter.js';
+import type { ColumnNode } from '../../ast/expression.js';
+import type { FunctionStrategy } from '../../functions/types.js';
+import type { TableFunctionStrategy } from '../../functions/table-types.js';
 import { StandardLimitOffsetPagination } from './pagination-strategy.js';
 import type { PaginationStrategy } from './pagination-strategy.js';
-import { CteCompiler } from './cte-compiler.js';
 import { NoReturningStrategy } from './returning-strategy.js';
 import type { ReturningStrategy } from './returning-strategy.js';
-import { JoinCompiler } from './join-compiler.js';
-import { GroupByCompiler } from './groupby-compiler.js';
-import { OrderByCompiler } from './orderby-compiler.js';
+import { NoUpsertStrategy } from './upsert-strategy.js';
+import type { UpsertStrategy } from './upsert-strategy.js';
+import { StandardSqlSourceCompiler } from './standard-sql-source-compiler.js';
+import { StandardSelectCompiler } from './standard-select-compiler.js';
+import { StandardInsertCompiler } from './standard-insert-compiler.js';
+import { StandardUpdateCompiler } from './standard-update-compiler.js';
+import { StandardDeleteCompiler } from './standard-delete-compiler.js';
+import type { StandardSqlCompilerServices } from './standard-sql-services.js';
+import type { SqlCompilerFactory, SqlCompilerSet } from './sql-compiler-set.js';
+
+export interface SqlDialectBaseOptions {
+  functionStrategy?: FunctionStrategy;
+  tableFunctionStrategy?: TableFunctionStrategy;
+  paginationStrategy?: PaginationStrategy;
+  returningStrategy?: ReturningStrategy;
+  upsertStrategy?: UpsertStrategy;
+  compilerFactory?: SqlCompilerFactory;
+  supportsDmlReturning?: boolean;
+}
 
 /**
- * Reusable SQL implementation built on the structural Dialect contract.
- * Dialects extend this only when its standard SELECT/DML behavior is useful.
+ * Thin assembly base for dialects that use MetalORM's reusable SQL compiler pieces.
+ *
+ * Query orchestration, source rendering, upsert behavior and returning behavior are
+ * injected components. Concrete dialects keep only syntax hooks that are genuinely
+ * intrinsic to that backend.
  */
 export abstract class SqlDialectBase extends DialectBase {
   abstract quoteIdentifier(id: string): string;
 
-  protected paginationStrategy: PaginationStrategy = new StandardLimitOffsetPagination();
-  protected returningStrategy: ReturningStrategy = new NoReturningStrategy();
+  protected readonly paginationStrategy: PaginationStrategy;
+  protected readonly returningStrategy: ReturningStrategy;
+  protected readonly upsertStrategy: UpsertStrategy;
 
-  protected compileSelectAst(ast: SelectQueryNode, ctx: CompilerContext): string {
-    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)
-    );
-    const baseAst: SelectQueryNode = hasSetOps
-      ? { ...ast, setOps: undefined, orderBy: undefined, limit: undefined, offset: undefined }
-      : ast;
-    const baseSelect = this.compileSelectCore(baseAst, ctx);
-    if (!hasSetOps) return `${ctes}${baseSelect}`;
-    return this.compileSelectWithSetOps(ast, baseSelect, ctes, ctx);
-  }
+  private readonly dmlReturningSupported: boolean;
+  private readonly sourceCompiler: StandardSqlSourceCompiler;
+  private readonly standardUpdateCompiler: StandardUpdateCompiler;
+  private readonly compilerSet: SqlCompilerSet;
 
-  private compileSelectWithSetOps(
-    ast: SelectQueryNode,
-    baseSelect: string,
-    ctes: string,
-    ctx: CompilerContext
-  ): string {
-    const compound = ast.setOps!
-      .map(op => `${op.operator} ${this.wrapSetOperand(this.compileSelectAst(op.query, ctx))}`)
-      .join(' ');
-    const orderBy = OrderByCompiler.compileOrderBy(
-      ast,
-      term => this.compileOrderingTerm(term, ctx),
-      this.renderOrderByNulls.bind(this),
-      this.renderOrderByCollation.bind(this)
-    );
-    const pagination = this.paginationStrategy.compilePagination(ast.limit, ast.offset);
-    const combined = `${this.wrapSetOperand(baseSelect)} ${compound}`;
-    return `${ctes}${combined}${orderBy}${pagination}`;
-  }
+  protected constructor(options: SqlDialectBaseOptions = {}) {
+    super(options.functionStrategy, options.tableFunctionStrategy);
 
-  protected compileInsertAst(ast: InsertQueryNode, ctx: CompilerContext): string {
-    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);
-    return `INSERT INTO ${table} (${columnList}) ${source}${upsert}${returning}`;
+    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: StandardSqlCompilerServices = {
+      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
+    };
+  }
+
+  override supportsDmlReturningClause(): boolean {
+    return this.dmlReturningSupported;
   }
 
-  protected compileUpsertClause(ast: InsertQueryNode, _ctx: CompilerContext): string {
-    void _ctx;
-    if (!ast.onConflict) return '';
-    throw new Error(`UPSERT/ON CONFLICT is not supported by dialect "${this.dialect}".`);
+  protected compileSelectAst(ast: SelectQueryNode, ctx: CompilerContext): string {
+    return this.compilerSet.select.compile(ast, ctx);
   }
 
-  protected compileReturning(returning: ColumnNode[] | undefined, ctx: CompilerContext): string {
-    return this.returningStrategy.compileReturning(returning, ctx);
+  protected compileInsertAst(ast: InsertQueryNode, ctx: CompilerContext): string {
+    return this.compilerSet.insert.compile(ast, ctx);
   }
 
-  protected compileInsertSource(source: InsertSourceNode, ctx: CompilerContext): string {
-    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(', ');
-      return `VALUES ${values}`;
-    }
-
-    const normalized = this.normalizeSelectAst(source.query);
-    return this.compileSelectAst(normalized, ctx).trim();
+  protected compileUpdateAst(ast: UpdateQueryNode, ctx: CompilerContext): string {
+    return this.compilerSet.update.compile(ast, ctx);
   }
 
-  protected compileInsertColumnList(columns: ColumnNode[]): string {
-    return columns.map(column => this.quoteIdentifier(column.name)).join(', ');
+  protected compileDeleteAst(ast: DeleteQueryNode, ctx: CompilerContext): string {
+    return this.compilerSet.delete.compile(ast, ctx);
   }
 
-  protected ensureConflictColumns(clause: UpsertClause, message: string): void {
-    if (!clause.target.columns.length) throw new Error(message);
+  protected compileUpsertClause(ast: InsertQueryNode, ctx: CompilerContext): string {
+    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)
+    });
   }
 
-  private compileSelectCore(ast: SelectQueryNode, ctx: CompilerContext): string {
-    const columns = this.compileSelectColumns(ast, ctx);
-    const from = this.compileFrom(ast.from, ctx);
-    const joins = JoinCompiler.compileJoins(
-      ast.joins,
+  protected compileReturning(returning: ColumnNode[] | undefined, ctx: CompilerContext): string {
+    return this.returningStrategy.compileReturning(
+      returning,
       ctx,
-      this.compileFrom.bind(this),
-      this.compileExpression.bind(this)
-    );
-    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)
+      id => this.quoteIdentifier(id)
     );
-    const pagination = this.paginationStrategy.compilePagination(ast.limit, ast.offset);
-    return `SELECT ${this.compileDistinct(ast)}${columns} FROM ${from}${joins}${whereClause}${groupBy}${having}${orderBy}${pagination}`;
   }
 
-  protected compileUpdateAst(ast: UpdateQueryNode, ctx: CompilerContext): string {
-    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}`;
+  protected ensureConflictColumns(clause: UpsertClause, message: string): void {
+    if (!clause.target.columns.length) throw new Error(message);
   }
 
   protected compileUpdateAssignments(
-    assignments: { column: ColumnNode; value: OperandNode }[],
+    assignments: UpdateAssignmentNode[],
     table: TableNode,
     ctx: CompilerContext
   ): string {
-    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);
   }
 
   protected compileSetTarget(column: ColumnNode, table: TableNode): string {
@@ -177,131 +168,43 @@ export abstract class SqlDialectBase extends DialectBase {
     return `${this.quoteIdentifier(tableQualifier)}.${this.quoteIdentifier(column.name)}`;
   }
 
-  protected compileDeleteAst(ast: DeleteQueryNode, ctx: CompilerContext): string {
-    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}`;
-  }
-
   protected formatReturningColumns(returning: ColumnNode[]): string {
-    return this.returningStrategy.formatReturningColumns(returning, this.quoteIdentifier.bind(this));
-  }
-
-  protected compileDistinct(ast: SelectQueryNode): string {
-    return ast.distinct ? 'DISTINCT ' : '';
-  }
-
-  protected compileSelectColumns(ast: SelectQueryNode, ctx: CompilerContext): string {
-    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)
+    );
   }
 
-  protected compileFrom(ast: SelectQueryNode['from'], ctx?: CompilerContext): string {
-    if (ast.type === 'FunctionTable') return this.compileFunctionTable(ast, ctx);
-    if (ast.type === 'DerivedTable') return this.compileDerivedTable(ast, ctx);
-    return this.compileTableSource(ast);
+  protected compileFrom(source: TableSourceNode, ctx?: CompilerContext): string {
+    return this.sourceCompiler.compileFrom(source, ctx);
   }
 
   protected compileFunctionTable(fn: FunctionTableNode, ctx?: CompilerContext): string {
-    const key = fn.key ?? fn.name;
-
-    if (ctx) {
-      const renderer = this.tableFunctionStrategy.getRenderer(key);
-      if (renderer) {
-        const compiledArgs = (fn.args ?? []).map(arg => this.compileOperand(arg, ctx));
-        return renderer({
-          node: fn,
-          compiledArgs,
-          compileOperand: operand => this.compileOperand(operand, ctx),
-          quoteIdentifier: this.quoteIdentifier.bind(this)
-        });
-      }
-
-      if (fn.key) {
-        throw new Error(`Table function "${key}" is not supported by dialect "${this.dialect}".`);
-      }
-    }
-
-    return FunctionTableFormatter.format(fn, ctx, {
-      quoteIdentifier: id => this.quoteIdentifier(id),
-      compileOperand: (node, compilerContext) => this.compileOperand(node, compilerContext)
-    });
+    return this.sourceCompiler.compileFunctionTable(fn, ctx);
   }
 
   protected compileDerivedTable(table: DerivedTableNode, ctx?: CompilerContext): string {
-    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);
   }
 
   protected compileTableSource(table: TableSourceNode): string {
-    if (table.type === 'FunctionTable') return this.compileFunctionTable(table as FunctionTableNode);
-    if (table.type === 'DerivedTable') return this.compileDerivedTable(table as DerivedTableNode);
-    const base = this.compileTableName(table);
-    return table.alias ? `${base} AS ${this.quoteIdentifier(table.alias)}` : base;
+    return this.sourceCompiler.compileTableSource(table);
   }
 
-  protected compileTableName(table: { name: string; schema?: string; alias?: string }): string {
-    if (table.schema) {
-      return `${this.quoteIdentifier(table.schema)}.${this.quoteIdentifier(table.name)}`;
-    }
-    return this.quoteIdentifier(table.name);
+  protected compileTableName(table: { name: string; schema?: string }): string {
+    return this.sourceCompiler.compileTableName(table);
   }
 
   protected compileTableReference(table: { name: string; schema?: string; alias?: string }): string {
-    const base = this.compileTableName(table);
-    return table.alias ? `${base} AS ${this.quoteIdentifier(table.alias)}` : base;
-  }
-
-  private compileUpdateFromClause(ast: UpdateQueryNode, ctx: CompilerContext): string {
-    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}`;
-  }
-
-  private compileDeleteUsingClause(ast: DeleteQueryNode, ctx: CompilerContext): string {
-    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}`;
-  }
-
-  protected compileHaving(ast: SelectQueryNode, ctx: CompilerContext): string {
-    if (!ast.having) return '';
-    return ` HAVING ${this.compileExpression(ast.having, ctx)}`;
+    return this.sourceCompiler.compileTableReference(table);
   }
 
   protected stripTrailingSemicolon(sql: string): string {
-    return sql.trim().replace(/;$/, '');
+    return this.sourceCompiler.stripTrailingSemicolon(sql);
   }
 
   protected wrapSetOperand(sql: string): string {
-    return `(${this.stripTrailingSemicolon(sql)})`;
+    return this.sourceCompiler.wrapSetOperand(sql);
   }
 
   protected renderOrderByNulls(order: OrderByNode): string | undefined {

package/src/core/dialect/base/standard-delete-compiler.ts

@@ -0,0 +1,37 @@
+import type { CompilerContext } from '../abstract.js';
+import type { DeleteQueryNode } from '../../ast/query.js';
+import { JoinCompiler } from './join-compiler.js';
+import { StandardSqlSourceCompiler } from './standard-sql-source-compiler.js';
+import type { StandardSqlCompilerServices } from './standard-sql-services.js';
+
+/** Standard DELETE orchestration, independent from concrete dialect classes. */
+export class StandardDeleteCompiler {
+  public constructor(
+    private readonly services: StandardSqlCompilerServices,
+    private readonly sources: StandardSqlSourceCompiler
+  ) {}
+
+  compile(ast: DeleteQueryNode, ctx: CompilerContext): string {
+    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}`;
+  }
+
+  private compileUsingClause(ast: DeleteQueryNode, ctx: CompilerContext): string {
+    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)
+    );
+    return ` USING ${usingTable}${joins}`;
+  }
+}

package/src/core/dialect/base/standard-insert-compiler.ts

@@ -0,0 +1,49 @@
+import type { CompilerContext } from '../abstract.js';
+import type { InsertQueryNode, InsertSourceNode, UpsertClause } from '../../ast/query.js';
+import type { ColumnNode } from '../../ast/expression.js';
+import { StandardSqlSourceCompiler } from './standard-sql-source-compiler.js';
+import type { StandardSqlCompilerServices } from './standard-sql-services.js';
+
+/** Standard INSERT orchestration, including VALUES/SELECT sources and upsert hook. */
+export class StandardInsertCompiler {
+  public constructor(
+    private readonly services: StandardSqlCompilerServices,
+    private readonly sources: StandardSqlSourceCompiler
+  ) {}
+
+  compile(ast: InsertQueryNode, ctx: CompilerContext): string {
+    if (!ast.columns.length) {
+      throw new Error('INSERT queries must specify columns.');
+    }
+
+    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}`;
+  }
+
+  compileSource(source: InsertSourceNode, ctx: CompilerContext): string {
+    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.services.compileOperand(value, ctx)).join(', ')})`)
+        .join(', ');
+      return `VALUES ${values}`;
+    }
+
+    const normalized = this.services.normalizeSelectAst(source.query);
+    return this.services.compileSelectAst(normalized, ctx).trim();
+  }
+
+  compileColumnList(columns: ColumnNode[]): string {
+    return columns.map(column => this.services.quoteIdentifier(column.name)).join(', ');
+  }
+
+  ensureConflictColumns(clause: UpsertClause, message: string): void {
+    if (!clause.target.columns.length) throw new Error(message);
+  }
+}