metal-orm 1.1.24 → 1.1.25

package/src/core/dialect/mssql/select-compiler.ts

@@ -0,0 +1,116 @@
+import type { OperandNode } from '../../ast/expression.js';
+import type { SelectQueryNode } from '../../ast/query.js';
+import type { CompilerContext } from '../abstract.js';
+import { OrderByCompiler } from '../base/orderby-compiler.js';
+import type { SqlAstCompiler } from '../base/sql-compiler-set.js';
+import type { StandardSqlCompilerServices } from '../base/standard-sql-services.js';
+import type { StandardSqlSourceCompiler } from '../base/standard-sql-source-compiler.js';
+
+export class MssqlSelectCompiler implements SqlAstCompiler<SelectQueryNode> {
+  constructor(
+    private readonly services: StandardSqlCompilerServices,
+    private readonly sources: StandardSqlSourceCompiler
+  ) {}
+
+  compile(ast: SelectQueryNode, ctx: CompilerContext): string {
+    const hasSetOps = !!(ast.setOps && ast.setOps.length);
+    const ctes = this.compileCtes(ast, ctx);
+    const baseAst: SelectQueryNode = hasSetOps
+      ? { ...ast, setOps: undefined, orderBy: undefined, limit: undefined, offset: undefined }
+      : 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}`;
+  }
+
+  private compileCore(ast: SelectQueryNode, ctx: CompilerContext): string {
+    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 as OperandNode, 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}`;
+  }
+
+  private compileOrderBy(ast: SelectQueryNode, ctx: CompilerContext): string {
+    return OrderByCompiler.compileOrderBy(
+      ast,
+      term => this.services.compileOrderingTerm(term, ctx),
+      order => this.services.renderOrderByNulls(order),
+      order => this.services.renderOrderByCollation(order)
+    );
+  }
+
+  private compilePagination(ast: SelectQueryNode, orderBy: string): string {
+    const hasLimit = ast.limit !== undefined;
+    const hasOffset = ast.offset !== undefined;
+    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;
+  }
+
+  private compileCtes(ast: SelectQueryNode, ctx: CompilerContext): string {
+    if (!ast.ctes || ast.ctes.length === 0) return '';
+    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 ${definitions} `;
+  }
+}

package/src/core/dialect/mssql/update-compiler.ts

@@ -0,0 +1,37 @@
+import type { UpdateQueryNode } from '../../ast/query.js';
+import type { CompilerContext } from '../abstract.js';
+import type { SqlAstCompiler } from '../base/sql-compiler-set.js';
+import type { StandardSqlCompilerServices } from '../base/standard-sql-services.js';
+import { StandardUpdateCompiler } from '../base/standard-update-compiler.js';
+import type { StandardSqlSourceCompiler } from '../base/standard-sql-source-compiler.js';
+
+export class MssqlUpdateCompiler implements SqlAstCompiler<UpdateQueryNode> {
+  private readonly standardUpdate: StandardUpdateCompiler;
+
+  constructor(
+    private readonly services: StandardSqlCompilerServices,
+    private readonly sources: StandardSqlSourceCompiler
+  ) {
+    this.standardUpdate = new StandardUpdateCompiler(services, sources);
+  }
+
+  compile(ast: UpdateQueryNode, ctx: CompilerContext): string {
+    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}`;
+  }
+}

package/src/core/dialect/mysql/index.ts

@@ -1,144 +1,51 @@
-import { CompilerContext } from '../abstract.js';
+import type { ProcedureCallNode } from '../../ast/procedure.js';
+import type { JsonPathNode, IsDistinctExpressionNode } from '../../ast/expression.js';
 import type { CompiledProcedureCall, ProcedureCompiler } from '../capabilities/procedure-compiler.js';
-import { JsonPathNode, IsDistinctExpressionNode } from '../../ast/expression.js';
-import { InsertQueryNode } from '../../ast/query.js';
 import { SqlDialectBase } from '../base/sql-dialect.js';
 import { MysqlFunctionStrategy } from './functions.js';
-import { ProcedureCallNode } from '../../ast/procedure.js';
+import { MySqlProcedureCompiler } from './procedure-compiler.js';
+import { MySqlUpsertStrategy } from './upsert.js';
 
-const sanitizeVariableSuffix = (value: string): string =>
-  value.replace(/[^a-zA-Z0-9_]/g, '_');
-
-/**
- * MySQL dialect implementation
- */
+/** MySQL dialect assembled from reusable compiler components. */
 export class MySqlDialect extends SqlDialectBase implements ProcedureCompiler {
   protected readonly dialect = 'mysql';
-  /**
-   * Creates a new MySqlDialect instance
-   */
+  private readonly procedureCompiler: MySqlProcedureCompiler;
+
   public constructor() {
-    super(new MysqlFunctionStrategy());
+    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: IsDistinctExpressionNode, ctx: CompilerContext): string => {
+      (node: IsDistinctExpressionNode, ctx): string => {
         const left = this.compileOperand(node.left, ctx);
         const right = this.compileOperand(node.right, ctx);
         const spaceship = `${left} <=> ${right}`;
-
-        if (node.operator === 'IS NOT DISTINCT FROM') {
-          return spaceship;
-        }
-
-        return `NOT (${spaceship})`;
+        return node.operator === 'IS NOT DISTINCT FROM'
+          ? spaceship
+          : `NOT (${spaceship})`;
       }
     );
   }
 
-  /**
-   * Quotes an identifier using MySQL backtick syntax
-   * @param id - Identifier to quote
-   * @returns Quoted identifier
-   */
   quoteIdentifier(id: string): string {
     return `\`${id}\``;
   }
 
-  /**
-   * Compiles JSON path expression using MySQL syntax
-   * @param node - JSON path node
-   * @returns MySQL JSON path expression
-   */
   protected compileJsonPath(node: JsonPathNode): string {
-    const col = `${this.quoteIdentifier(node.column.table)}.${this.quoteIdentifier(node.column.name)}`;
-    // MySQL 5.7+ uses col->'$.path'
-    return `${col}->'${node.path}'`;
-  }
-
-  protected compileUpsertClause(ast: InsertQueryNode, ctx: CompilerContext): string {
-    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 col = this.quoteIdentifier(noOpColumn.name);
-      return ` ON DUPLICATE KEY UPDATE ${col} = ${col}`;
-    }
-
-    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}`;
+    const column = `${this.quoteIdentifier(node.column.table)}.${this.quoteIdentifier(node.column.name)}`;
+    return `${column}->'${node.path}'`;
   }
 
   compileProcedureCall(ast: ProcedureCallNode): CompiledProcedureCall {
-    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 prelude: string[] = [];
-    const callArgs: string[] = [];
-    const outVars: Array<{ variable: string; name: string }> = [];
-
-    ast.params.forEach((param, index) => {
-      const suffix = sanitizeVariableSuffix(param.name || `p${index + 1}`);
-      const variable = `@__metal_${suffix}_${index + 1}`;
-
-      if (param.direction === 'in') {
-        if (!param.value) {
-          throw new Error(`Procedure parameter "${param.name}" requires a value for direction "in".`);
-        }
-        callArgs.push(this.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)};`);
-      }
-
-      callArgs.push(variable);
-      outVars.push({ variable, name: param.name });
-    });
-
-    const statements: string[] = [];
-    if (prelude.length) {
-      statements.push(...prelude);
-    }
-    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};`);
-    }
-
-    return {
-      sql: statements.join(' '),
-      params: [...ctx.params],
-      outParams: {
-        source: outVars.length ? 'lastResultSet' : 'none',
-        names: outVars.map(item => item.name)
-      }
-    };
+    return this.procedureCompiler.compileProcedureCall(ast);
   }
 }

package/src/core/dialect/mysql/procedure-compiler.ts

@@ -0,0 +1,67 @@
+import type { ProcedureCallNode } from '../../ast/procedure.js';
+import type {
+  CompiledProcedureCall,
+  ProcedureCompiler,
+  ProcedureCompilerServices
+} from '../capabilities/procedure-compiler.js';
+
+const sanitizeVariableSuffix = (value: string): string =>
+  value.replace(/[^a-zA-Z0-9_]/g, '_');
+
+export class MySqlProcedureCompiler implements ProcedureCompiler {
+  constructor(private readonly services: ProcedureCompilerServices) {}
+
+  compileProcedureCall(ast: ProcedureCallNode): CompiledProcedureCall {
+    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: string[] = [];
+    const callArgs: string[] = [];
+    const outVars: Array<{ variable: string; name: string }> = [];
+
+    ast.params.forEach((param, index) => {
+      const suffix = sanitizeVariableSuffix(param.name || `p${index + 1}`);
+      const variable = `@__metal_${suffix}_${index + 1}`;
+
+      if (param.direction === 'in') {
+        if (!param.value) {
+          throw new Error(`Procedure parameter "${param.name}" requires a value for direction "in".`);
+        }
+        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.services.compileOperand(param.value, ctx)};`);
+      }
+
+      callArgs.push(variable);
+      outVars.push({ variable, name: param.name });
+    });
+
+    const statements: string[] = [];
+    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)
+      }
+    };
+  }
+}

package/src/core/dialect/mysql/upsert.ts

@@ -0,0 +1,42 @@
+import type { CompilerContext } from '../abstract.js';
+import type { InsertQueryNode } from '../../ast/query.js';
+import type {
+  UpsertCompilationServices,
+  UpsertStrategy
+} from '../base/upsert-strategy.js';
+
+export class MySqlUpsertStrategy implements UpsertStrategy {
+  compile(
+    ast: InsertQueryNode,
+    ctx: CompilerContext,
+    services: UpsertCompilationServices
+  ): string {
+    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 col = services.quoteIdentifier(noOpColumn.name);
+      return ` ON DUPLICATE KEY UPDATE ${col} = ${col}`;
+    }
+
+    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 = services.quoteIdentifier(assignment.column.name);
+        const value = services.compileOperand(assignment.value, ctx);
+        return `${target} = ${value}`;
+      })
+      .join(', ');
+    return ` ON DUPLICATE KEY UPDATE ${assignments}`;
+  }
+}

package/src/core/dialect/postgres/index.ts

@@ -1,41 +1,48 @@
-import { CompilerContext } from '../abstract.js';
+import type { ProcedureCallNode } from '../../ast/procedure.js';
+import type { BitwiseExpressionNode, ColumnNode, JsonPathNode } from '../../ast/expression.js';
+import type { TableNode } from '../../ast/query.js';
 import type { CompiledProcedureCall, ProcedureCompiler } from '../capabilities/procedure-compiler.js';
-import { JsonPathNode, ColumnNode, BitwiseExpressionNode } from '../../ast/expression.js';
-import { InsertQueryNode, TableNode } from '../../ast/query.js';
 import { SqlDialectBase } from '../base/sql-dialect.js';
 import { PostgresFunctionStrategy } from './functions.js';
 import { PostgresTableFunctionStrategy } from './table-functions.js';
-import { ProcedureCallNode } from '../../ast/procedure.js';
+import { PostgresProcedureCompiler } from './procedure-compiler.js';
+import { PostgresReturningStrategy } from './returning.js';
+import { PostgresUpsertStrategy } from './upsert.js';
 
-/**
- * PostgreSQL dialect implementation
- */
+/** PostgreSQL dialect assembled from reusable compiler components. */
 export class PostgresDialect extends SqlDialectBase implements ProcedureCompiler {
   protected readonly dialect = 'postgres';
-  /**
-   * Creates a new PostgresDialect instance
-   */
+  private readonly procedureCompiler: PostgresProcedureCompiler;
+
   public 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: BitwiseExpressionNode, ctx) => {
       const left = this.compileOperand(node.left, ctx);
       const right = this.compileOperand(node.right, ctx);
-      const op = node.operator === '^' ? '#' : node.operator;
-      return `${left} ${op} ${right}`;
+      const operator = node.operator === '^' ? '#' : node.operator;
+      return `${left} ${operator} ${right}`;
     });
     this.registerOperandCompiler('BitwiseExpression', (node: BitwiseExpressionNode, ctx) => {
       const left = this.compileOperand(node.left, ctx);
       const right = this.compileOperand(node.right, ctx);
-      const op = node.operator === '^' ? '#' : node.operator;
-      return `(${left} ${op} ${right})`;
+      const operator = node.operator === '^' ? '#' : node.operator;
+      return `(${left} ${operator} ${right})`;
     });
   }
 
-  /**
-   * Quotes an identifier using PostgreSQL double-quote syntax
-   * @param id - Identifier to quote
-   * @returns Quoted identifier
-   */
   quoteIdentifier(id: string): string {
     return `"${id}"`;
   }
@@ -44,92 +51,18 @@ export class PostgresDialect extends SqlDialectBase implements ProcedureCompiler
     return `$${index}`;
   }
 
-  /**
-   * Compiles JSON path expression using PostgreSQL syntax
-   * @param node - JSON path node
-   * @returns PostgreSQL JSON path expression
-   */
   protected compileJsonPath(node: JsonPathNode): string {
-    const col = `${this.quoteIdentifier(node.column.table)}.${this.quoteIdentifier(node.column.name)}`;
-    // Postgres uses col->>'path' for text extraction
-    return `${col}->>'${node.path}'`;
-  }
-
-  protected compileReturning(returning: ColumnNode[] | undefined, ctx: CompilerContext): string {
-    void ctx;
-    if (!returning || returning.length === 0) return '';
-    const columns = this.formatReturningColumns(returning);
-    return ` RETURNING ${columns}`;
-  }
-
-  protected compileUpsertClause(ast: InsertQueryNode, ctx: CompilerContext): string {
-    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(col => this.quoteIdentifier(col.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}`;
+    const column = `${this.quoteIdentifier(node.column.table)}.${this.quoteIdentifier(node.column.name)}`;
+    return `${column}->>'${node.path}'`;
   }
 
-  supportsDmlReturningClause(): boolean {
-    return true;
+  /** PostgreSQL requires unqualified column names in SET clauses. */
+  protected compileSetTarget(column: ColumnNode, _table: TableNode): string {
+    void _table;
+    return this.quoteIdentifier(column.name);
   }
 
   compileProcedureCall(ast: ProcedureCallNode): CompiledProcedureCall {
-    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: string[] = [];
-    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
-      }
-    };
-  }
-
-  /**
-   * PostgreSQL requires unqualified column names in SET clause
-   */
-  protected compileSetTarget(column: ColumnNode, _table: TableNode): string {
-    return this.quoteIdentifier(column.name);
+    return this.procedureCompiler.compileProcedureCall(ast);
   }
 }

package/src/core/dialect/postgres/procedure-compiler.ts

@@ -0,0 +1,41 @@
+import type { ProcedureCallNode } from '../../ast/procedure.js';
+import type {
+  CompiledProcedureCall,
+  ProcedureCompiler,
+  ProcedureCompilerServices
+} from '../capabilities/procedure-compiler.js';
+
+export class PostgresProcedureCompiler implements ProcedureCompiler {
+  constructor(private readonly services: ProcedureCompilerServices) {}
+
+  compileProcedureCall(ast: ProcedureCallNode): CompiledProcedureCall {
+    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: string[] = [];
+    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
+      }
+    };
+  }
+}

package/src/core/dialect/postgres/returning.ts

@@ -0,0 +1,4 @@
+import { StandardReturningStrategy } from '../base/returning-strategy.js';
+
+/** PostgreSQL uses standard SQL RETURNING with qualified columns. */
+export class PostgresReturningStrategy extends StandardReturningStrategy {}