metal-orm 1.1.24 → 1.1.26

package/package.json

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

package/src/core/dialect/abstract.ts

@@ -1,25 +1,9 @@
 import type {
-  SelectQueryNode,
-  InsertQueryNode,
-  UpdateQueryNode,
   DeleteQueryNode,
-  SetOperationKind,
-  OrderingTerm
+  InsertQueryNode,
+  SelectQueryNode,
+  UpdateQueryNode
 } from '../ast/query.js';
-import type {
-  ExpressionNode,
-  ColumnNode,
-  OperandNode,
-  FunctionNode,
-  JsonPathNode
-} from '../ast/expression.js';
-import type { DialectName } from '../sql/sql.js';
-import type { FunctionStrategy } from '../functions/types.js';
-import { StandardFunctionStrategy } from '../functions/standard-strategy.js';
-import type { TableFunctionStrategy } from '../functions/table-types.js';
-import { StandardTableFunctionStrategy } from '../functions/standard-table-strategy.js';
-import { ExpressionCompilerRegistry } from './base/expression-compiler-registry.js';
-import { SelectAstNormalizer } from './base/select-ast-normalizer.js';
 
 /** Context for SQL compilation with parameter management. */
 export interface CompilerContext {
@@ -50,219 +34,13 @@ export interface DeleteCompiler {
 }
 
 /**
- * Public dialect contract consumed by builders and the ORM runtime.
- * Optional backend features such as stored procedures live in dedicated
- * capability interfaces; mutation-wide behavior shared by the runtime stays
- * in this small core contract.
+ * Structural contract consumed by query builders and the ORM runtime.
+ *
+ * A dialect is assembled from compiler components. There is intentionally no
+ * base class: inheritance is not part of the extension model.
  */
 export interface Dialect
   extends SelectCompiler, InsertCompiler, UpdateCompiler, DeleteCompiler {
   quoteIdentifier(id: string): string;
   supportsDmlReturningClause(): boolean;
 }
-
-/**
- * Shared implementation infrastructure for SQL dialects.
- *
- * This is deliberately separate from the public Dialect contract: custom
- * dialects may extend this class, extend SqlDialectBase, or use composition.
- */
-export abstract class DialectBase implements Dialect {
-  protected abstract readonly dialect: DialectName;
-
-  private readonly expressionCompilerRegistry: ExpressionCompilerRegistry;
-  private readonly selectAstNormalizer: SelectAstNormalizer;
-  protected readonly functionStrategy: FunctionStrategy;
-  protected readonly tableFunctionStrategy: TableFunctionStrategy;
-
-  protected constructor(
-    functionStrategy?: FunctionStrategy,
-    tableFunctionStrategy?: TableFunctionStrategy
-  ) {
-    this.functionStrategy = functionStrategy ?? new StandardFunctionStrategy();
-    this.tableFunctionStrategy = tableFunctionStrategy ?? new StandardTableFunctionStrategy();
-    this.selectAstNormalizer = new SelectAstNormalizer(kind => this.supportsSetOperation(kind));
-    this.expressionCompilerRegistry = new ExpressionCompilerRegistry({
-      quoteIdentifier: id => this.quoteIdentifier(id),
-      compileSelectAst: (ast, ctx) => this.compileSelectAst(ast, ctx),
-      compileSelectForExists: (ast, ctx) => this.compileSelectForExists(ast, ctx),
-      compileJsonPath: node => this.compileJsonPath(node),
-      compileFunctionOperand: (node, ctx) => this.compileFunctionOperand(node, ctx),
-      describe: () => this.constructor.name
-    });
-  }
-
-  compileSelect(ast: SelectQueryNode): CompiledQuery {
-    const ctx = this.createCompilerContext();
-    const normalized = this.normalizeSelectAst(ast);
-    const rawSql = this.compileSelectAst(normalized, ctx).trim();
-    return {
-      sql: rawSql.endsWith(';') ? rawSql : `${rawSql};`,
-      params: [...ctx.params]
-    };
-  }
-
-  compileInsert(ast: InsertQueryNode): CompiledQuery {
-    const ctx = this.createCompilerContext();
-    const rawSql = this.compileInsertAst(ast, ctx).trim();
-    return {
-      sql: rawSql.endsWith(';') ? rawSql : `${rawSql};`,
-      params: [...ctx.params]
-    };
-  }
-
-  compileUpdate(ast: UpdateQueryNode): CompiledQuery {
-    const ctx = this.createCompilerContext();
-    const rawSql = this.compileUpdateAst(ast, ctx).trim();
-    return {
-      sql: rawSql.endsWith(';') ? rawSql : `${rawSql};`,
-      params: [...ctx.params]
-    };
-  }
-
-  compileDelete(ast: DeleteQueryNode): CompiledQuery {
-    const ctx = this.createCompilerContext();
-    const rawSql = this.compileDeleteAst(ast, ctx).trim();
-    return {
-      sql: rawSql.endsWith(';') ? rawSql : `${rawSql};`,
-      params: [...ctx.params]
-    };
-  }
-
-  supportsDmlReturningClause(): boolean {
-    return false;
-  }
-
-  protected abstract compileSelectAst(ast: SelectQueryNode, ctx: CompilerContext): string;
-  protected abstract compileInsertAst(ast: InsertQueryNode, ctx: CompilerContext): string;
-  protected abstract compileUpdateAst(ast: UpdateQueryNode, ctx: CompilerContext): string;
-  protected abstract compileDeleteAst(ast: DeleteQueryNode, ctx: CompilerContext): string;
-
-  abstract quoteIdentifier(id: string): string;
-
-  protected compileWhere(where: ExpressionNode | undefined, ctx: CompilerContext): string {
-    if (!where) return '';
-    return ` WHERE ${this.compileExpression(where, ctx)}`;
-  }
-
-  protected compileReturning(
-    returning: ColumnNode[] | undefined,
-    _ctx: CompilerContext
-  ): string {
-    void _ctx;
-    if (!returning || returning.length === 0) return '';
-    throw new Error('RETURNING is not supported by this dialect.');
-  }
-
-  protected compileSelectForExists(ast: SelectQueryNode, ctx: CompilerContext): string {
-    const normalized = this.normalizeSelectAst(ast);
-    const full = this.compileSelectAst(normalized, ctx).trim().replace(/;$/, '');
-
-    if (normalized.setOps && normalized.setOps.length > 0) {
-      return `SELECT 1 FROM (${full}) AS _exists`;
-    }
-
-    const upper = full.toUpperCase();
-    const fromIndex = upper.indexOf(' FROM ');
-    if (fromIndex === -1) return full;
-
-    return `SELECT 1${full.slice(fromIndex)}`;
-  }
-
-  protected createCompilerContext(): CompilerContext {
-    const params: unknown[] = [];
-    let counter = 0;
-    return {
-      params,
-      addParameter: (value: unknown) => {
-        counter += 1;
-        params.push(value);
-        return this.formatPlaceholder(counter);
-      }
-    };
-  }
-
-  protected formatPlaceholder(_index: number): string {
-    void _index;
-    return '?';
-  }
-
-  protected supportsSetOperation(_kind: SetOperationKind): boolean {
-    void _kind;
-    return true;
-  }
-
-  protected normalizeSelectAst(ast: SelectQueryNode): SelectQueryNode {
-    return this.selectAstNormalizer.normalize(ast);
-  }
-
-  protected registerExpressionCompiler<T extends ExpressionNode>(
-    type: T['type'],
-    compiler: (node: T, ctx: CompilerContext) => string
-  ): void {
-    this.expressionCompilerRegistry.registerExpressionCompiler(type, compiler);
-  }
-
-  protected registerOperandCompiler<T extends OperandNode>(
-    type: T['type'],
-    compiler: (node: T, ctx: CompilerContext) => string
-  ): void {
-    this.expressionCompilerRegistry.registerOperandCompiler(type, compiler);
-  }
-
-  protected compileExpression(node: ExpressionNode, ctx: CompilerContext): string {
-    return this.expressionCompilerRegistry.compileExpression(node, ctx);
-  }
-
-  protected compileOperand(node: OperandNode, ctx: CompilerContext): string {
-    return this.expressionCompilerRegistry.compileOperand(node, ctx);
-  }
-
-  protected compileOrderingTerm(term: OrderingTerm, ctx: CompilerContext): string {
-    return this.expressionCompilerRegistry.compileOrderingTerm(term, ctx);
-  }
-
-  protected compileJsonPath(_node: JsonPathNode): string {
-    void _node;
-    throw new Error('JSON Path not supported by this dialect');
-  }
-
-  protected compileFunctionOperand(fnNode: FunctionNode, ctx: CompilerContext): string {
-    const compiledArgs = fnNode.args.map(arg => this.compileOperand(arg, ctx));
-    const renderer = this.functionStrategy.getRenderer(fnNode.name);
-    if (renderer) {
-      return renderer({
-        node: fnNode,
-        compiledArgs,
-        compileOperand: operand => this.compileOperand(operand, ctx)
-      });
-    }
-    return `${fnNode.name}(${compiledArgs.join(', ')})`;
-  }
-
-  /** Creates a minimal dialect implementation for isolated compiler tests. */
-  static create(
-    functionStrategy?: FunctionStrategy,
-    tableFunctionStrategy?: TableFunctionStrategy
-  ): Dialect {
-    class TestDialect extends DialectBase {
-      protected readonly dialect: DialectName = 'sqlite';
-      quoteIdentifier(id: string): string {
-        return `"${id}"`;
-      }
-      protected compileSelectAst(): never {
-        throw new Error('Not implemented');
-      }
-      protected compileInsertAst(): never {
-        throw new Error('Not implemented');
-      }
-      protected compileUpdateAst(): never {
-        throw new Error('Not implemented');
-      }
-      protected compileDeleteAst(): never {
-        throw new Error('Not implemented');
-      }
-    }
-    return new TestDialect(functionStrategy, tableFunctionStrategy);
-  }
-}

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-composer.ts

@@ -0,0 +1,294 @@
+import type {
+  DeleteQueryNode,
+  InsertQueryNode,
+  OrderByNode,
+  OrderingTerm,
+  SelectQueryNode,
+  SetOperationKind,
+  TableNode,
+  UpdateQueryNode
+} from '../../ast/query.js';
+import type {
+  ColumnNode,
+  ExpressionNode,
+  FunctionNode,
+  JsonPathNode,
+  OperandNode
+} from '../../ast/expression.js';
+import type { FunctionStrategy } from '../../functions/types.js';
+import { StandardFunctionStrategy } from '../../functions/standard-strategy.js';
+import type { TableFunctionStrategy } from '../../functions/table-types.js';
+import { StandardTableFunctionStrategy } from '../../functions/standard-table-strategy.js';
+import type { CompilerContext, Dialect } from '../abstract.js';
+import type { ProcedureCompilerServices } from '../capabilities/procedure-compiler.js';
+import { ExpressionCompilerRegistry } from './expression-compiler-registry.js';
+import { SelectAstNormalizer } from './select-ast-normalizer.js';
+import { StandardLimitOffsetPagination } from './pagination-strategy.js';
+import type { PaginationStrategy } from './pagination-strategy.js';
+import { NoReturningStrategy } from './returning-strategy.js';
+import type { ReturningStrategy } from './returning-strategy.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 SqlDialectExpressionApi {
+  registerExpressionCompiler<T extends ExpressionNode>(
+    type: T['type'],
+    compiler: (node: T, ctx: CompilerContext) => string
+  ): void;
+  registerOperandCompiler<T extends OperandNode>(
+    type: T['type'],
+    compiler: (node: T, ctx: CompilerContext) => string
+  ): void;
+  compileExpression(node: ExpressionNode, ctx: CompilerContext): string;
+  compileOperand(node: OperandNode, ctx: CompilerContext): string;
+  compileOrderingTerm(term: OrderingTerm, ctx: CompilerContext): string;
+}
+
+export interface SqlDialectRuntimeServices extends ProcedureCompilerServices {
+  compileExpression(node: ExpressionNode, ctx: CompilerContext): string;
+  compileOrderingTerm(term: OrderingTerm, ctx: CompilerContext): string;
+  normalizeSelectAst(ast: SelectQueryNode): SelectQueryNode;
+  compileSelectAst(ast: SelectQueryNode, ctx: CompilerContext): string;
+}
+
+export interface SqlDialectComposition {
+  dialect: Dialect;
+  runtime: SqlDialectRuntimeServices;
+}
+
+export interface SqlDialectConfig {
+  /** Human-readable/backend identifier used by diagnostics and strategies. */
+  name: string;
+  quoteIdentifier(id: string): string;
+  formatPlaceholder?(index: number): string;
+  compileJsonPath?(node: JsonPathNode): string;
+  functionStrategy?: FunctionStrategy;
+  tableFunctionStrategy?: TableFunctionStrategy;
+  paginationStrategy?: PaginationStrategy;
+  returningStrategy?: ReturningStrategy;
+  upsertStrategy?: UpsertStrategy;
+  compilerFactory?: SqlCompilerFactory;
+  supportsDmlReturning?: boolean;
+  supportsSetOperation?(kind: SetOperationKind): boolean;
+  compileSetTarget?(column: ColumnNode, table: TableNode): string;
+  renderOrderByNulls?(order: OrderByNode): string | undefined;
+  renderOrderByCollation?(order: OrderByNode): string | undefined;
+  configureExpressions?(api: SqlDialectExpressionApi): void;
+  describe?: string;
+}
+
+const terminate = (sql: string): string => {
+  const trimmed = sql.trim();
+  return trimmed.endsWith(';') ? trimmed : `${trimmed};`;
+};
+
+/**
+ * Assembles a full SQL dialect from independent compiler components.
+ * No inheritance or concrete dialect class participates in the compilation path.
+ */
+export const composeSqlDialect = (config: SqlDialectConfig): SqlDialectComposition => {
+  const functionStrategy = config.functionStrategy ?? new StandardFunctionStrategy();
+  const tableFunctionStrategy = config.tableFunctionStrategy ?? new StandardTableFunctionStrategy();
+  const paginationStrategy = config.paginationStrategy ?? new StandardLimitOffsetPagination();
+  const returningStrategy = config.returningStrategy ?? new NoReturningStrategy();
+  const upsertStrategy = config.upsertStrategy ?? new NoUpsertStrategy();
+  const selectAstNormalizer = new SelectAstNormalizer(
+    kind => config.supportsSetOperation?.(kind) ?? true
+  );
+
+  let compilerSet!: SqlCompilerSet;
+  let expressionRegistry!: ExpressionCompilerRegistry;
+
+  const createCompilerContext = (): CompilerContext => {
+    const params: unknown[] = [];
+    let counter = 0;
+    return {
+      params,
+      addParameter(value: unknown): string {
+        counter += 1;
+        params.push(value);
+        return config.formatPlaceholder?.(counter) ?? '?';
+      }
+    };
+  };
+
+  const compileSelectAst = (ast: SelectQueryNode, ctx: CompilerContext): string =>
+    compilerSet.select.compile(ast, ctx);
+
+  const normalizeSelectAst = (ast: SelectQueryNode): SelectQueryNode =>
+    selectAstNormalizer.normalize(ast);
+
+  const compileSelectForExists = (ast: SelectQueryNode, ctx: CompilerContext): string => {
+    const normalized = normalizeSelectAst(ast);
+    const full = compileSelectAst(normalized, ctx).trim().replace(/;$/, '');
+    if (normalized.setOps && normalized.setOps.length > 0) {
+      return `SELECT 1 FROM (${full}) AS _exists`;
+    }
+    const fromIndex = full.toUpperCase().indexOf(' FROM ');
+    return fromIndex === -1 ? full : `SELECT 1${full.slice(fromIndex)}`;
+  };
+
+  const compileJsonPath = (node: JsonPathNode): string => {
+    if (!config.compileJsonPath) {
+      throw new Error(`JSON Path not supported by dialect "${config.name}".`);
+    }
+    return config.compileJsonPath(node);
+  };
+
+  const compileFunctionOperand = (node: FunctionNode, ctx: CompilerContext): string => {
+    const compiledArgs = node.args.map(arg => expressionRegistry.compileOperand(arg, ctx));
+    const renderer = functionStrategy.getRenderer(node.name);
+    if (renderer) {
+      return renderer({
+        node,
+        compiledArgs,
+        compileOperand: operand => expressionRegistry.compileOperand(operand, ctx)
+      });
+    }
+    return `${node.name}(${compiledArgs.join(', ')})`;
+  };
+
+  expressionRegistry = new ExpressionCompilerRegistry({
+    quoteIdentifier: config.quoteIdentifier,
+    compileSelectAst,
+    compileSelectForExists,
+    compileJsonPath,
+    compileFunctionOperand,
+    describe: () => config.describe ?? config.name
+  });
+
+  const compileSetTarget = (column: ColumnNode, table: TableNode): string => {
+    if (config.compileSetTarget) return config.compileSetTarget(column, table);
+    const columnTable = column.table ?? table.alias ?? table.name;
+    const tableQualifier = table.alias && column.table === table.name
+      ? table.alias
+      : columnTable;
+    return tableQualifier
+      ? `${config.quoteIdentifier(tableQualifier)}.${config.quoteIdentifier(column.name)}`
+      : config.quoteIdentifier(column.name);
+  };
+
+  let standardUpdate!: StandardUpdateCompiler;
+  const services: StandardSqlCompilerServices = {
+    getDialectName: () => config.name,
+    getPaginationStrategy: () => paginationStrategy,
+    getTableFunctionStrategy: () => tableFunctionStrategy,
+    quoteIdentifier: config.quoteIdentifier,
+    compileOperand: (node, ctx) => expressionRegistry.compileOperand(node, ctx),
+    compileExpression: (node, ctx) => expressionRegistry.compileExpression(node, ctx),
+    compileOrderingTerm: (term, ctx) => expressionRegistry.compileOrderingTerm(term, ctx),
+    normalizeSelectAst: normalizeSelectAst,
+    compileSelectAst,
+    compileReturning: (returning, ctx) =>
+      returningStrategy.compileReturning(returning, ctx, config.quoteIdentifier),
+    compileUpsertClause: (ast, ctx) =>
+      upsertStrategy.compile(ast, ctx, {
+        getDialectName: () => config.name,
+        quoteIdentifier: config.quoteIdentifier,
+        compileOperand: (node, compilerContext) =>
+          expressionRegistry.compileOperand(node, compilerContext),
+        compileExpression: (node, compilerContext) =>
+          expressionRegistry.compileExpression(node, compilerContext),
+        compileUpdateAssignments: (assignments, table, compilerContext) =>
+          standardUpdate.compileAssignments(assignments, table, compilerContext)
+      }),
+    compileSetTarget,
+    renderOrderByNulls: order =>
+      config.renderOrderByNulls?.(order) ?? (order.nulls ? ` NULLS ${order.nulls}` : ''),
+    renderOrderByCollation: order =>
+      config.renderOrderByCollation?.(order) ?? (order.collation ? ` COLLATE ${order.collation}` : '')
+  };
+
+  const sources = new StandardSqlSourceCompiler(services);
+  const standardSelect = new StandardSelectCompiler(services, sources);
+  const standardInsert = new StandardInsertCompiler(services, sources);
+  standardUpdate = new StandardUpdateCompiler(services, sources);
+  const standardDelete = new StandardDeleteCompiler(services, sources);
+  const overrides = config.compilerFactory?.({ services, sources }) ?? {};
+  compilerSet = {
+    select: overrides.select ?? standardSelect,
+    insert: overrides.insert ?? standardInsert,
+    update: overrides.update ?? standardUpdate,
+    delete: overrides.delete ?? standardDelete
+  };
+
+  const expressionApi: SqlDialectExpressionApi = {
+    registerExpressionCompiler<T extends ExpressionNode>(
+      type: T['type'],
+      compiler: (node: T, ctx: CompilerContext) => string
+    ): void {
+      expressionRegistry.registerExpressionCompiler(type, compiler);
+    },
+    registerOperandCompiler<T extends OperandNode>(
+      type: T['type'],
+      compiler: (node: T, ctx: CompilerContext) => string
+    ): void {
+      expressionRegistry.registerOperandCompiler(type, compiler);
+    },
+    compileExpression(node: ExpressionNode, ctx: CompilerContext): string {
+      return expressionRegistry.compileExpression(node, ctx);
+    },
+    compileOperand(node: OperandNode, ctx: CompilerContext): string {
+      return expressionRegistry.compileOperand(node, ctx);
+    },
+    compileOrderingTerm(term: OrderingTerm, ctx: CompilerContext): string {
+      return expressionRegistry.compileOrderingTerm(term, ctx);
+    }
+  };
+  config.configureExpressions?.(expressionApi);
+
+  const dialect: Dialect = {
+    quoteIdentifier: config.quoteIdentifier,
+    supportsDmlReturningClause: () => config.supportsDmlReturning ?? false,
+    compileSelect(ast: SelectQueryNode) {
+      const ctx = createCompilerContext();
+      return {
+        sql: terminate(compileSelectAst(normalizeSelectAst(ast), ctx)),
+        params: [...ctx.params]
+      };
+    },
+    compileInsert(ast: InsertQueryNode) {
+      const ctx = createCompilerContext();
+      return {
+        sql: terminate(compilerSet.insert.compile(ast, ctx)),
+        params: [...ctx.params]
+      };
+    },
+    compileUpdate(ast: UpdateQueryNode) {
+      const ctx = createCompilerContext();
+      return {
+        sql: terminate(compilerSet.update.compile(ast, ctx)),
+        params: [...ctx.params]
+      };
+    },
+    compileDelete(ast: DeleteQueryNode) {
+      const ctx = createCompilerContext();
+      return {
+        sql: terminate(compilerSet.delete.compile(ast, ctx)),
+        params: [...ctx.params]
+      };
+    }
+  };
+
+  const runtime: SqlDialectRuntimeServices = {
+    quoteIdentifier: config.quoteIdentifier,
+    createCompilerContext,
+    compileOperand: (node, ctx) => expressionRegistry.compileOperand(node, ctx),
+    compileExpression: (node, ctx) => expressionRegistry.compileExpression(node, ctx),
+    compileOrderingTerm: (term, ctx) => expressionRegistry.compileOrderingTerm(term, ctx),
+    normalizeSelectAst: normalizeSelectAst,
+    compileSelectAst
+  };
+
+  return { dialect, runtime };
+};
+
+export const createSqlDialect = (config: SqlDialectConfig): Dialect =>
+  composeSqlDialect(config).dialect;