metal-orm 1.1.22 → 1.1.23

package/src/core/dialect/base/expression-compiler-registry.ts

@@ -0,0 +1,254 @@
+import type { CompilerContext } from '../abstract.js';
+import type { OrderingTerm, SelectQueryNode } from '../../ast/query.js';
+import {
+  type ExpressionNode,
+  type BinaryExpressionNode,
+  type LogicalExpressionNode,
+  type NotExpressionNode,
+  type NullExpressionNode,
+  type InExpressionNode,
+  type ExistsExpressionNode,
+  type LiteralNode,
+  type ColumnNode,
+  type OperandNode,
+  type FunctionNode,
+  type JsonPathNode,
+  type ScalarSubqueryNode,
+  type CaseExpressionNode,
+  type CastExpressionNode,
+  type WindowFunctionNode,
+  type BetweenExpressionNode,
+  type ArithmeticExpressionNode,
+  type BitwiseExpressionNode,
+  type CollateExpressionNode,
+  type AliasRefNode,
+  type IsDistinctExpressionNode,
+  isOperandNode
+} from '../../ast/expression.js';
+
+export interface ExpressionCompilerHost {
+  quoteIdentifier(id: string): string;
+  compileSelectAst(ast: SelectQueryNode, ctx: CompilerContext): string;
+  compileSelectForExists(ast: SelectQueryNode, ctx: CompilerContext): string;
+  compileJsonPath(node: JsonPathNode): string;
+  compileFunctionOperand(node: FunctionNode, ctx: CompilerContext): string;
+  describe(): string;
+}
+
+type ExpressionCompiler = (node: ExpressionNode, ctx: CompilerContext) => string;
+type OperandCompiler = (node: OperandNode, ctx: CompilerContext) => string;
+
+/**
+ * Owns expression/operand dispatch independently from dialect query compilation.
+ * Dialects can replace individual node compilers without inheriting a second AST
+ * dispatcher or duplicating the default SQL expression behavior.
+ */
+export class ExpressionCompilerRegistry {
+  private readonly expressionCompilers = new Map<string, ExpressionCompiler>();
+  private readonly operandCompilers = new Map<string, OperandCompiler>();
+
+  constructor(private readonly host: ExpressionCompilerHost) {
+    this.registerDefaultOperandCompilers();
+    this.registerDefaultExpressionCompilers();
+  }
+
+  registerExpressionCompiler<T extends ExpressionNode>(
+    type: T['type'],
+    compiler: (node: T, ctx: CompilerContext) => string
+  ): void {
+    this.expressionCompilers.set(type, compiler as ExpressionCompiler);
+  }
+
+  registerOperandCompiler<T extends OperandNode>(
+    type: T['type'],
+    compiler: (node: T, ctx: CompilerContext) => string
+  ): void {
+    this.operandCompilers.set(type, compiler as OperandCompiler);
+  }
+
+  compileExpression(node: ExpressionNode, ctx: CompilerContext): string {
+    const compiler = this.expressionCompilers.get(node.type);
+    if (!compiler) {
+      throw new Error(`Unsupported expression node type "${node.type}" for ${this.host.describe()}`);
+    }
+    return compiler(node, ctx);
+  }
+
+  compileOperand(node: OperandNode, ctx: CompilerContext): string {
+    const compiler = this.operandCompilers.get(node.type);
+    if (!compiler) {
+      throw new Error(`Unsupported operand node type "${node.type}" for ${this.host.describe()}`);
+    }
+    return compiler(node, ctx);
+  }
+
+  compileOrderingTerm(term: OrderingTerm, ctx: CompilerContext): string {
+    if (isOperandNode(term)) {
+      return this.compileOperand(term, ctx);
+    }
+    return `(${this.compileExpression(term as ExpressionNode, ctx)})`;
+  }
+
+  private registerDefaultExpressionCompilers(): void {
+    this.registerExpressionCompiler('BinaryExpression', (binary: BinaryExpressionNode, ctx) => {
+      const left = this.compileOperand(binary.left, ctx);
+      const right = this.compileOperand(binary.right, ctx);
+      const base = `${left} ${binary.operator} ${right}`;
+      if (binary.escape) {
+        const escapeOperand = this.compileOperand(binary.escape, ctx);
+        return `${base} ESCAPE ${escapeOperand}`;
+      }
+      return base;
+    });
+
+    this.registerExpressionCompiler('LogicalExpression', (logical: LogicalExpressionNode, ctx) => {
+      if (logical.operands.length === 0) return '';
+      const parts = logical.operands.map(op => {
+        const compiled = this.compileExpression(op, ctx);
+        return op.type === 'LogicalExpression' ? `(${compiled})` : compiled;
+      });
+      return parts.join(` ${logical.operator} `);
+    });
+
+    this.registerExpressionCompiler('NotExpression', (notExpr: NotExpressionNode, ctx) => {
+      const operand = this.compileExpression(notExpr.operand, ctx);
+      return `NOT (${operand})`;
+    });
+
+    this.registerExpressionCompiler('NullExpression', (nullExpr: NullExpressionNode, ctx) => {
+      const left = this.compileOperand(nullExpr.left, ctx);
+      return `${left} ${nullExpr.operator}`;
+    });
+
+    this.registerExpressionCompiler('InExpression', (inExpr: InExpressionNode, ctx) => {
+      const left = this.compileOperand(inExpr.left, ctx);
+      if (Array.isArray(inExpr.right)) {
+        const values = inExpr.right.map(v => this.compileOperand(v, ctx)).join(', ');
+        return `${left} ${inExpr.operator} (${values})`;
+      }
+      const subquerySql = this.host.compileSelectAst(inExpr.right.query, ctx).trim().replace(/;$/, '');
+      return `${left} ${inExpr.operator} (${subquerySql})`;
+    });
+
+    this.registerExpressionCompiler('ExistsExpression', (existsExpr: ExistsExpressionNode, ctx) => {
+      const subquerySql = this.host.compileSelectForExists(existsExpr.subquery, ctx);
+      return `${existsExpr.operator} (${subquerySql})`;
+    });
+
+    this.registerExpressionCompiler('BetweenExpression', (betweenExpr: BetweenExpressionNode, ctx) => {
+      const left = this.compileOperand(betweenExpr.left, ctx);
+      const lower = this.compileOperand(betweenExpr.lower, ctx);
+      const upper = this.compileOperand(betweenExpr.upper, ctx);
+      return `${left} ${betweenExpr.operator} ${lower} AND ${upper}`;
+    });
+
+    this.registerExpressionCompiler('ArithmeticExpression', (arith: ArithmeticExpressionNode, ctx) => {
+      const left = this.compileOperand(arith.left, ctx);
+      const right = this.compileOperand(arith.right, ctx);
+      return `${left} ${arith.operator} ${right}`;
+    });
+
+    this.registerExpressionCompiler('BitwiseExpression', (bitwise: BitwiseExpressionNode, ctx) => {
+      const left = this.compileOperand(bitwise.left, ctx);
+      const right = this.compileOperand(bitwise.right, ctx);
+      return `${left} ${bitwise.operator} ${right}`;
+    });
+
+    this.registerExpressionCompiler('IsDistinctExpression', (node: IsDistinctExpressionNode, ctx) => {
+      const left = this.compileOperand(node.left, ctx);
+      const right = this.compileOperand(node.right, ctx);
+      return `${left} ${node.operator} ${right}`;
+    });
+  }
+
+  private registerDefaultOperandCompilers(): void {
+    this.registerOperandCompiler('Literal', (literal: LiteralNode, ctx) =>
+      ctx.addParameter(literal.value)
+    );
+
+    this.registerOperandCompiler('AliasRef', (alias: AliasRefNode) =>
+      this.host.quoteIdentifier(alias.name)
+    );
+
+    this.registerOperandCompiler('Column', (column: ColumnNode) =>
+      `${this.host.quoteIdentifier(column.table)}.${this.host.quoteIdentifier(column.name)}`
+    );
+
+    this.registerOperandCompiler('Function', (fnNode: FunctionNode, ctx) =>
+      this.host.compileFunctionOperand(fnNode, ctx)
+    );
+
+    this.registerOperandCompiler('JsonPath', (path: JsonPathNode) =>
+      this.host.compileJsonPath(path)
+    );
+
+    this.registerOperandCompiler('ScalarSubquery', (node: ScalarSubqueryNode, ctx) => {
+      const sql = this.host.compileSelectAst(node.query, ctx).trim().replace(/;$/, '');
+      return `(${sql})`;
+    });
+
+    this.registerOperandCompiler('CaseExpression', (node: CaseExpressionNode, ctx) => {
+      const parts = ['CASE'];
+      for (const { when, then } of node.conditions) {
+        parts.push(`WHEN ${this.compileExpression(when, ctx)} THEN ${this.compileOperand(then, ctx)}`);
+      }
+      if (node.else) {
+        parts.push(`ELSE ${this.compileOperand(node.else, ctx)}`);
+      }
+      parts.push('END');
+      return parts.join(' ');
+    });
+
+    this.registerOperandCompiler('Cast', (node: CastExpressionNode, ctx) => {
+      const value = this.compileOperand(node.expression, ctx);
+      return `CAST(${value} AS ${node.castType})`;
+    });
+
+    this.registerOperandCompiler('WindowFunction', (node: WindowFunctionNode, ctx) => {
+      let result = `${node.name}(`;
+      if (node.args.length > 0) {
+        result += node.args.map(arg => this.compileOperand(arg, ctx)).join(', ');
+      }
+      result += ') OVER (';
+
+      const parts: string[] = [];
+      if (node.partitionBy && node.partitionBy.length > 0) {
+        const partitionClause = 'PARTITION BY ' + node.partitionBy.map(col =>
+          `${this.host.quoteIdentifier(col.table)}.${this.host.quoteIdentifier(col.name)}`
+        ).join(', ');
+        parts.push(partitionClause);
+      }
+
+      if (node.orderBy && node.orderBy.length > 0) {
+        const orderClause = 'ORDER BY ' + node.orderBy.map(o => {
+          const term = this.compileOrderingTerm(o.term, ctx);
+          const collation = o.collation ? ` COLLATE ${o.collation}` : '';
+          const nulls = o.nulls ? ` NULLS ${o.nulls}` : '';
+          return `${term} ${o.direction}${collation}${nulls}`;
+        }).join(', ');
+        parts.push(orderClause);
+      }
+
+      result += parts.join(' ');
+      result += ')';
+      return result;
+    });
+
+    this.registerOperandCompiler('ArithmeticExpression', (node: ArithmeticExpressionNode, ctx) => {
+      const left = this.compileOperand(node.left, ctx);
+      const right = this.compileOperand(node.right, ctx);
+      return `(${left} ${node.operator} ${right})`;
+    });
+
+    this.registerOperandCompiler('BitwiseExpression', (node: BitwiseExpressionNode, ctx) => {
+      const left = this.compileOperand(node.left, ctx);
+      const right = this.compileOperand(node.right, ctx);
+      return `(${left} ${node.operator} ${right})`;
+    });
+
+    this.registerOperandCompiler('Collate', (node: CollateExpressionNode, ctx) => {
+      const expr = this.compileOperand(node.expression, ctx);
+      return `${expr} COLLATE ${node.collation}`;
+    });
+  }
+}

package/src/core/dialect/base/function-table-formatter.ts

@@ -1,112 +1,74 @@
-import { CompilerContext } from '../abstract.js';
-import { OperandNode } from '../../ast/expression.js';
-import { FunctionTableNode } from '../../ast/query.js';
-import { SqlDialectBase } from './sql-dialect.js';
+import type { CompilerContext } from '../abstract.js';
+import type { OperandNode } from '../../ast/expression.js';
+import type { FunctionTableNode } from '../../ast/query.js';
+
+export interface FunctionTableFormattingContext {
+  quoteIdentifier(id: string): string;
+  compileOperand(node: OperandNode, ctx: CompilerContext): string;
+}
 
 /**
- * Formatter for function table expressions (e.g., LATERAL unnest(...) WITH ORDINALITY).
- * Encapsulates logic for generating SQL function table syntax including LATERAL, aliases, and column lists.
+ * Formats function-table expressions without depending on a dialect base class.
+ * SQL compilers provide only the two operations this formatter actually needs.
  */
 export class FunctionTableFormatter {
-  /**
-   * Formats a function table node into SQL syntax.
-   * @param fn - The function table node containing schema, name, args, and aliases.
-   * @param ctx - Optional compiler context for operand compilation.
-   * @param dialect - The dialect instance for compiling operands.
-   * @returns SQL function table expression (e.g., "LATERAL schema.func(args) WITH ORDINALITY AS alias(col1, col2)").
-   */
-  static format(fn: FunctionTableNode, ctx?: CompilerContext, dialect?: SqlDialectBase): string {
-    const schemaPart = this.formatSchema(fn, dialect);
-    const args = this.formatArgs(fn, ctx, dialect);
+  static format(
+    fn: FunctionTableNode,
+    ctx: CompilerContext | undefined,
+    formatter: FunctionTableFormattingContext
+  ): string {
+    const schemaPart = this.formatSchema(fn, formatter);
+    const args = this.formatArgs(fn, ctx, formatter);
     const base = this.formatBase(fn, schemaPart, args);
     const lateral = this.formatLateral(fn);
-    const alias = this.formatAlias(fn, dialect);
-    const colAliases = this.formatColumnAliases(fn, dialect);
+    const alias = this.formatAlias(fn, formatter);
+    const colAliases = this.formatColumnAliases(fn, formatter);
     return `${lateral}${base}${alias}${colAliases}`;
   }
 
-  /**
-   * Formats the schema prefix for the function name.
-   * @param fn - The function table node.
-   * @param dialect - The dialect instance for quoting identifiers.
-   * @returns Schema prefix (e.g., "schema.") or empty string.
-   * @internal
-   */
-  private static formatSchema(fn: FunctionTableNode, dialect?: SqlDialectBase): string {
+  private static formatSchema(
+    fn: FunctionTableNode,
+    formatter: FunctionTableFormattingContext
+  ): string {
     if (!fn.schema) return '';
-    const quoted = dialect ? dialect.quoteIdentifier(fn.schema) : fn.schema;
-    return `${quoted}.`;
+    return `${formatter.quoteIdentifier(fn.schema)}.`;
   }
 
-  /**
-   * Formats function arguments into SQL syntax.
-   * @param fn - The function table node containing arguments.
-   * @param ctx - Optional compiler context for operand compilation.
-   * @param dialect - The dialect instance for compiling operands.
-   * @returns Comma-separated function arguments.
-   * @internal
-   */
-  private static formatArgs(fn: FunctionTableNode, ctx?: CompilerContext, dialect?: SqlDialectBase): string {
+  private static formatArgs(
+    fn: FunctionTableNode,
+    ctx: CompilerContext | undefined,
+    formatter: FunctionTableFormattingContext
+  ): string {
     return (fn.args || [])
-      .map((a: OperandNode) => {
-        if (ctx && dialect) {
-          return (dialect as unknown as { compileOperand(n: OperandNode, c: CompilerContext): string }).compileOperand(a, ctx);
-        }
-        return String(a);
-      })
+      .map((arg: OperandNode) => ctx ? formatter.compileOperand(arg, ctx) : String(arg))
       .join(', ');
   }
 
-  /**
-   * Formats the base function call with WITH ORDINALITY if present.
-   * @param fn - The function table node.
-   * @param schemaPart - Formatted schema prefix.
-   * @param args - Formatted function arguments.
-   * @param dialect - The dialect instance for quoting identifiers.
-   * @returns Base function call expression (e.g., "schema.func(args) WITH ORDINALITY").
-   * @internal
-   */
   private static formatBase(fn: FunctionTableNode, schemaPart: string, args: string): string {
     const ordinality = fn.withOrdinality ? ' WITH ORDINALITY' : '';
     return `${schemaPart}${fn.name}(${args})${ordinality}`;
   }
 
-  /**
-   * Formats the LATERAL keyword if present.
-   * @param fn - The function table node.
-   * @returns "LATERAL " or empty string.
-   * @internal
-   */
   private static formatLateral(fn: FunctionTableNode): string {
     return fn.lateral ? 'LATERAL ' : '';
   }
 
-  /**
-   * Formats the table alias for the function table.
-   * @param fn - The function table node.
-   * @param dialect - The dialect instance for quoting identifiers.
-   * @returns " AS alias" or empty string.
-   * @internal
-   */
-  private static formatAlias(fn: FunctionTableNode, dialect?: SqlDialectBase): string {
+  private static formatAlias(
+    fn: FunctionTableNode,
+    formatter: FunctionTableFormattingContext
+  ): string {
     if (!fn.alias) return '';
-    const quoted = dialect ? dialect.quoteIdentifier(fn.alias) : fn.alias;
-    return ` AS ${quoted}`;
+    return ` AS ${formatter.quoteIdentifier(fn.alias)}`;
   }
 
-  /**
-   * Formats column aliases for the function table result columns.
-   * @param fn - The function table node containing column aliases.
-   * @param dialect - The dialect instance for quoting identifiers.
-   * @returns "(col1, col2, ...)" or empty string.
-   * @internal
-   */
-  private static formatColumnAliases(fn: FunctionTableNode, dialect?: SqlDialectBase): string {
+  private static formatColumnAliases(
+    fn: FunctionTableNode,
+    formatter: FunctionTableFormattingContext
+  ): string {
     if (!fn.columnAliases || !fn.columnAliases.length) return '';
     const aliases = fn.columnAliases
-      .map(col => dialect ? dialect.quoteIdentifier(col) : col)
+      .map(col => formatter.quoteIdentifier(col))
       .join(', ');
     return `(${aliases})`;
   }
 }
-

package/src/core/dialect/base/select-ast-normalizer.ts

@@ -0,0 +1,61 @@
+import type {
+  CommonTableExpressionNode,
+  SelectQueryNode,
+  SetOperationKind
+} from '../../ast/query.js';
+
+export type SetOperationSupport = (kind: SetOperationKind) => boolean;
+
+/**
+ * Normalizes compound SELECT ASTs independently from SQL rendering.
+ *
+ * Responsibilities are intentionally limited to set-operation validation and
+ * CTE hoisting, so dialect SQL compilers consume one stable normalized shape.
+ */
+export class SelectAstNormalizer {
+  constructor(private readonly supportsSetOperation: SetOperationSupport) {}
+
+  normalize(ast: SelectQueryNode): SelectQueryNode {
+    this.validateSetOperations(ast, true);
+    const { normalized, hoistedCtes } = this.hoistCtes(ast);
+    const combinedCtes = [...(normalized.ctes ?? []), ...hoistedCtes];
+    return combinedCtes.length ? { ...normalized, ctes: combinedCtes } : normalized;
+  }
+
+  private validateSetOperations(ast: SelectQueryNode, isOutermost: boolean): void {
+    const hasSetOps = !!(ast.setOps && ast.setOps.length);
+    if (!isOutermost && (ast.orderBy || ast.limit !== undefined || ast.offset !== undefined)) {
+      throw new Error('ORDER BY / LIMIT / OFFSET are only allowed on the outermost compound query.');
+    }
+
+    if (!hasSetOps) return;
+
+    for (const op of ast.setOps!) {
+      if (!this.supportsSetOperation(op.operator)) {
+        throw new Error(`Set operation ${op.operator} is not supported by this dialect.`);
+      }
+      this.validateSetOperations(op.query, false);
+    }
+  }
+
+  private hoistCtes(ast: SelectQueryNode): {
+    normalized: SelectQueryNode;
+    hoistedCtes: CommonTableExpressionNode[];
+  } {
+    let hoisted: CommonTableExpressionNode[] = [];
+
+    const normalizedSetOps = ast.setOps?.map(op => {
+      const { normalized: child, hoistedCtes: childHoisted } = this.hoistCtes(op.query);
+      const childCtes = child.ctes ?? [];
+      if (childCtes.length) hoisted = hoisted.concat(childCtes);
+      hoisted = hoisted.concat(childHoisted);
+      const queryWithoutCtes = childCtes.length ? { ...child, ctes: undefined } : child;
+      return { ...op, query: queryWithoutCtes };
+    });
+
+    const normalized: SelectQueryNode = normalizedSetOps
+      ? { ...ast, setOps: normalizedSetOps }
+      : ast;
+    return { normalized, hoistedCtes: hoisted };
+  }
+}

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

@@ -1,5 +1,6 @@
-import { CompilerContext, Dialect } from '../abstract.js';
-import {
+import { DialectBase } from '../abstract.js';
+import type { CompilerContext } from '../abstract.js';
+import type {
   SelectQueryNode,
   InsertQueryNode,
   UpdateQueryNode,
@@ -12,22 +13,22 @@ import {
   OrderByNode,
   TableNode
 } from '../../ast/query.js';
-import { ColumnNode, OperandNode } from '../../ast/expression.js';
+import type { ColumnNode, OperandNode } from '../../ast/expression.js';
 import { FunctionTableFormatter } from './function-table-formatter.js';
-import { PaginationStrategy, StandardLimitOffsetPagination } from './pagination-strategy.js';
+import { StandardLimitOffsetPagination } from './pagination-strategy.js';
+import type { PaginationStrategy } from './pagination-strategy.js';
 import { CteCompiler } from './cte-compiler.js';
-import { ReturningStrategy, NoReturningStrategy } from './returning-strategy.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';
 
-
 /**
- * Base class for SQL dialects.
- * Provides a common framework for compiling AST nodes into SQL strings.
- * Specific dialects should extend this class and implement dialect-specific logic.
+ * Reusable SQL implementation built on the structural Dialect contract.
+ * Dialects extend this only when its standard SELECT/DML behavior is useful.
  */
-export abstract class SqlDialectBase extends Dialect {
+export abstract class SqlDialectBase extends DialectBase {
   abstract quoteIdentifier(id: string): string;
 
   protected paginationStrategy: PaginationStrategy = new StandardLimitOffsetPagination();
@@ -40,16 +41,14 @@ export abstract class SqlDialectBase extends Dialect {
       ctx,
       this.quoteIdentifier.bind(this),
       this.compileSelectAst.bind(this),
-      this.normalizeSelectAst?.bind(this) ?? ((a) => a),
+      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}`;
-    }
+    if (!hasSetOps) return `${ctes}${baseSelect}`;
     return this.compileSelectWithSetOps(ast, baseSelect, ctes, ctx);
   }
 
@@ -116,9 +115,7 @@ export abstract class SqlDialectBase extends Dialect {
   }
 
   protected ensureConflictColumns(clause: UpsertClause, message: string): void {
-    if (!clause.target.columns.length) {
-      throw new Error(message);
-    }
+    if (!clause.target.columns.length) throw new Error(message);
   }
 
   private compileSelectCore(ast: SelectQueryNode, ctx: CompilerContext): string {
@@ -159,8 +156,7 @@ export abstract class SqlDialectBase extends Dialect {
   ): string {
     return assignments
       .map(assignment => {
-        const col = assignment.column;
-        const target = this.compileSetTarget(col, table);
+        const target = this.compileSetTarget(assignment.column, table);
         const value = this.compileOperand(assignment.value, ctx);
         return `${target} = ${value}`;
       })
@@ -175,13 +171,9 @@ export abstract class SqlDialectBase extends Dialect {
     const baseTableName = table.name;
     const alias = table.alias;
     const columnTable = column.table ?? alias ?? baseTableName;
-    const tableQualifier =
-      alias && column.table === baseTableName ? alias : columnTable;
-
-    if (!tableQualifier) {
-      return this.quoteIdentifier(column.name);
-    }
+    const tableQualifier = alias && column.table === baseTableName ? alias : columnTable;
 
+    if (!tableQualifier) return this.quoteIdentifier(column.name);
     return `${this.quoteIdentifier(tableQualifier)}.${this.quoteIdentifier(column.name)}`;
   }
 
@@ -202,28 +194,21 @@ export abstract class SqlDialectBase extends Dialect {
   }
 
   protected compileSelectColumns(ast: SelectQueryNode, ctx: CompilerContext): string {
-    if (!ast.columns || ast.columns.length === 0) {
-      return '*';
-    }
-    return ast.columns.map(c => {
-      const expr = this.compileOperand(c, ctx);
-      if (c.alias) {
-        if (c.alias.includes('(')) return c.alias;
-        return `${expr} AS ${this.quoteIdentifier(c.alias)}`;
+    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(', ');
   }
 
   protected compileFrom(ast: SelectQueryNode['from'], ctx?: CompilerContext): string {
-    const tableSource = ast;
-    if (tableSource.type === 'FunctionTable') {
-      return this.compileFunctionTable(tableSource, ctx);
-    }
-    if (tableSource.type === 'DerivedTable') {
-      return this.compileDerivedTable(tableSource, ctx);
-    }
-    return this.compileTableSource(tableSource);
+    if (ast.type === 'FunctionTable') return this.compileFunctionTable(ast, ctx);
+    if (ast.type === 'DerivedTable') return this.compileDerivedTable(ast, ctx);
+    return this.compileTableSource(ast);
   }
 
   protected compileFunctionTable(fn: FunctionTableNode, ctx?: CompilerContext): string {
@@ -246,13 +231,14 @@ export abstract class SqlDialectBase extends Dialect {
       }
     }
 
-    return FunctionTableFormatter.format(fn, ctx, this);
+    return FunctionTableFormatter.format(fn, ctx, {
+      quoteIdentifier: id => this.quoteIdentifier(id),
+      compileOperand: (node, compilerContext) => this.compileOperand(node, compilerContext)
+    });
   }
 
   protected compileDerivedTable(table: DerivedTableNode, ctx?: CompilerContext): string {
-    if (!table.alias) {
-      throw new Error('Derived tables must have an alias.');
-    }
+    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(', ')})`
@@ -261,12 +247,8 @@ export abstract class SqlDialectBase extends Dialect {
   }
 
   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);
-    }
+    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;
   }
@@ -285,9 +267,7 @@ export abstract class SqlDialectBase extends Dialect {
 
   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.');
-    }
+    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,
@@ -300,9 +280,7 @@ export abstract class SqlDialectBase extends Dialect {
 
   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.');
-    }
+    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,
@@ -323,8 +301,7 @@ export abstract class SqlDialectBase extends Dialect {
   }
 
   protected wrapSetOperand(sql: string): string {
-    const trimmed = this.stripTrailingSemicolon(sql);
-    return `(${trimmed})`;
+    return `(${this.stripTrailingSemicolon(sql)})`;
   }
 
   protected renderOrderByNulls(order: OrderByNode): string | undefined {