metal-orm 1.0.38 → 1.0.40

package/src/core/dialect/base/groupby-compiler.ts

@@ -1,4 +1,6 @@
-import { SelectQueryNode } from '../../ast/query.js';
+import { OrderingTerm, SelectQueryNode } from '../../ast/query.js';
+
+type TermRenderer = (term: OrderingTerm) => string;
 
 /**
  * Compiler for GROUP BY clauses in SELECT statements.
@@ -8,14 +10,12 @@ export class GroupByCompiler {
   /**
    * Compiles GROUP BY clause from a SELECT query AST.
    * @param ast - The SELECT query AST containing grouping columns.
-   * @param quoteIdentifier - Function to quote identifiers according to dialect rules.
+   * @param renderTerm - Function to render a grouping term.
    * @returns SQL GROUP BY clause (e.g., " GROUP BY table.col1, table.col2") or empty string if no grouping.
    */
-  static compileGroupBy(ast: SelectQueryNode, quoteIdentifier: (id: string) => string): string {
+  static compileGroupBy(ast: SelectQueryNode, renderTerm: TermRenderer): string {
     if (!ast.groupBy || ast.groupBy.length === 0) return '';
-    const cols = ast.groupBy
-      .map(c => `${quoteIdentifier(c.table)}.${quoteIdentifier(c.name)}`)
-      .join(', ');
+    const cols = ast.groupBy.map(renderTerm).join(', ');
     return ` GROUP BY ${cols}`;
   }
 }

package/src/core/dialect/base/orderby-compiler.ts

@@ -1,4 +1,8 @@
-import { SelectQueryNode } from '../../ast/query.js';
+import { OrderByNode, SelectQueryNode } from '../../ast/query.js';
+
+type NullsRenderer = (order: OrderByNode) => string | undefined;
+type CollationRenderer = (order: OrderByNode) => string | undefined;
+type TermRenderer = (term: OrderByNode['term']) => string;
 
 /**
  * Compiler for ORDER BY clauses in SELECT statements.
@@ -8,14 +12,24 @@ export class OrderByCompiler {
   /**
    * Compiles ORDER BY clause from a SELECT query AST.
    * @param ast - The SELECT query AST containing sort specifications.
-   * @param quoteIdentifier - Function to quote identifiers according to dialect rules.
+   * @param renderTerm - Function to render an ordering term.
+   * @param renderNulls - Optional function to render NULLS FIRST/LAST.
+   * @param renderCollation - Optional function to render COLLATE clause.
    * @returns SQL ORDER BY clause (e.g., " ORDER BY table.col1 ASC, table.col2 DESC") or empty string if no ordering.
    */
-  static compileOrderBy(ast: SelectQueryNode, quoteIdentifier: (id: string) => string): string {
+  static compileOrderBy(
+    ast: SelectQueryNode,
+    renderTerm: TermRenderer,
+    renderNulls?: NullsRenderer,
+    renderCollation?: CollationRenderer
+  ): string {
     if (!ast.orderBy || ast.orderBy.length === 0) return '';
-    const parts = ast.orderBy
-      .map(o => `${quoteIdentifier(o.column.table)}.${quoteIdentifier(o.column.name)} ${o.direction}`)
-      .join(', ');
+    const parts = ast.orderBy.map(o => {
+      const term = renderTerm(o.term);
+      const collation = renderCollation ? renderCollation(o) : o.collation ? ` COLLATE ${o.collation}` : '';
+      const nulls = renderNulls ? renderNulls(o) : o.nulls ? ` NULLS ${o.nulls}` : '';
+      return `${term} ${o.direction}${collation}${nulls}`;
+    }).join(', ');
     return ` ORDER BY ${parts}`;
   }
 }

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

@@ -1,102 +1,112 @@
-import { CompilerContext, Dialect } from '../abstract.js';
-import { SelectQueryNode, InsertQueryNode, UpdateQueryNode, DeleteQueryNode, TableSourceNode, DerivedTableNode, FunctionTableNode } from '../../ast/query.js';
-import { ColumnNode } from '../../ast/expression.js';
+import { CompilerContext, Dialect } from '../abstract.js';
+import { SelectQueryNode, InsertQueryNode, UpdateQueryNode, DeleteQueryNode, TableSourceNode, DerivedTableNode, FunctionTableNode, OrderByNode } from '../../ast/query.js';
+import { ColumnNode } from '../../ast/expression.js';
 import { FunctionTableFormatter } from './function-table-formatter.js';
-import { PaginationStrategy, StandardLimitOffsetPagination } from './pagination-strategy.js';
-import { CteCompiler } from './cte-compiler.js';
-import { ReturningStrategy, NoReturningStrategy } from './returning-strategy.js';
-import { JoinCompiler } from './join-compiler.js';
-import { GroupByCompiler } from './groupby-compiler.js';
-import { OrderByCompiler } from './orderby-compiler.js';
-
-
-export abstract class SqlDialectBase extends Dialect {
-  abstract quoteIdentifier(id: string): string;
-
-  protected paginationStrategy: PaginationStrategy = new StandardLimitOffsetPagination();
-  protected returningStrategy: ReturningStrategy = new NoReturningStrategy();
-
-  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) ?? ((a) => a),
-      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 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, this.quoteIdentifier.bind(this));
-    const pagination = this.paginationStrategy.compilePagination(ast.limit, ast.offset);
-    const combined = `${this.wrapSetOperand(baseSelect)} ${compound}`;
-    return `${ctes}${combined}${orderBy}${pagination}`;
-  }
-
-  protected compileInsertAst(ast: InsertQueryNode, ctx: CompilerContext): string {
-    const table = this.compileTableName(ast.into);
-    const columnList = this.compileInsertColumnList(ast.columns);
-    const values = this.compileInsertValues(ast.values, ctx);
-    const returning = this.compileReturning(ast.returning, ctx);
-    return `INSERT INTO ${table} (${columnList}) VALUES ${values}${returning}`;
-  }
-
-  protected compileReturning(returning: ColumnNode[] | undefined, ctx: CompilerContext): string {
-    return this.returningStrategy.compileReturning(returning, ctx);
-  }
-
+import { PaginationStrategy, StandardLimitOffsetPagination } from './pagination-strategy.js';
+import { CteCompiler } from './cte-compiler.js';
+import { ReturningStrategy, NoReturningStrategy } from './returning-strategy.js';
+import { JoinCompiler } from './join-compiler.js';
+import { GroupByCompiler } from './groupby-compiler.js';
+import { OrderByCompiler } from './orderby-compiler.js';
+
+
+export abstract class SqlDialectBase extends Dialect {
+  abstract quoteIdentifier(id: string): string;
+
+  protected paginationStrategy: PaginationStrategy = new StandardLimitOffsetPagination();
+  protected returningStrategy: ReturningStrategy = new NoReturningStrategy();
+
+  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) ?? ((a) => a),
+      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 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 compileInsertAst(ast: InsertQueryNode, ctx: CompilerContext): string {
+    const table = this.compileTableName(ast.into);
+    const columnList = this.compileInsertColumnList(ast.columns);
+    const values = this.compileInsertValues(ast.values, ctx);
+    const returning = this.compileReturning(ast.returning, ctx);
+    return `INSERT INTO ${table} (${columnList}) VALUES ${values}${returning}`;
+  }
+
+  protected compileReturning(returning: ColumnNode[] | undefined, ctx: CompilerContext): string {
+    return this.returningStrategy.compileReturning(returning, ctx);
+  }
+
   private compileInsertColumnList(columns: ColumnNode[]): string {
     return columns.map(column => this.quoteIdentifier(column.name)).join(', ');
   }
-
-  private compileInsertValues(values: any[][], ctx: CompilerContext): string {
-    return values
-      .map(row => `(${row.map(value => this.compileOperand(value, ctx)).join(', ')})`)
-      .join(', ');
-  }
-
-  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, ctx, this.compileFrom.bind(this), this.compileExpression.bind(this));
-    const whereClause = this.compileWhere(ast.where, ctx);
-    const groupBy = GroupByCompiler.compileGroupBy(ast, this.quoteIdentifier.bind(this));
-    const having = this.compileHaving(ast, ctx);
-    const orderBy = OrderByCompiler.compileOrderBy(ast, this.quoteIdentifier.bind(this));
-    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 table = this.compileTableName(ast.table);
-    const assignments = this.compileUpdateAssignments(ast.set, ctx);
-    const whereClause = this.compileWhere(ast.where, ctx);
-    const returning = this.compileReturning(ast.returning, ctx);
-    return `UPDATE ${table} SET ${assignments}${whereClause}${returning}`;
-  }
-
-  private compileUpdateAssignments(
-    assignments: { column: ColumnNode; value: any }[],
-    ctx: CompilerContext
-  ): string {
+
+  private compileInsertValues(values: any[][], ctx: CompilerContext): string {
+    return values
+      .map(row => `(${row.map(value => this.compileOperand(value, ctx)).join(', ')})`)
+      .join(', ');
+  }
+
+  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, 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)
+    );
+    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 table = this.compileTableName(ast.table);
+    const assignments = this.compileUpdateAssignments(ast.set, ctx);
+    const whereClause = this.compileWhere(ast.where, ctx);
+    const returning = this.compileReturning(ast.returning, ctx);
+    return `UPDATE ${table} SET ${assignments}${whereClause}${returning}`;
+  }
+
+  private compileUpdateAssignments(
+    assignments: { column: ColumnNode; value: any }[],
+    ctx: CompilerContext
+  ): string {
     return assignments
       .map(assignment => {
         const col = assignment.column;
@@ -106,33 +116,33 @@ export abstract class SqlDialectBase extends Dialect {
       })
       .join(', ');
   }
-
-  protected compileDeleteAst(ast: DeleteQueryNode, ctx: CompilerContext): string {
-    const table = this.compileTableName(ast.from);
-    const whereClause = this.compileWhere(ast.where, ctx);
-    const returning = this.compileReturning(ast.returning, ctx);
-    return `DELETE FROM ${table}${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 {
-    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)}`;
-      }
-      return expr;
-    }).join(', ');
-  }
-
+
+  protected compileDeleteAst(ast: DeleteQueryNode, ctx: CompilerContext): string {
+    const table = this.compileTableName(ast.from);
+    const whereClause = this.compileWhere(ast.where, ctx);
+    const returning = this.compileReturning(ast.returning, ctx);
+    return `DELETE FROM ${table}${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 {
+    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)}`;
+      }
+      return expr;
+    }).join(', ');
+  }
+
   protected compileFrom(ast: SelectQueryNode['from'], ctx?: CompilerContext): string {
     const tableSource = ast as any;
     if (tableSource.type === 'FunctionTable') {
@@ -176,18 +186,26 @@ export abstract class SqlDialectBase extends Dialect {
     }
     return this.quoteIdentifier(table.name);
   }
-
-  protected compileHaving(ast: SelectQueryNode, ctx: CompilerContext): string {
-    if (!ast.having) return '';
-    return ` HAVING ${this.compileExpression(ast.having, ctx)}`;
-  }
-
-  protected stripTrailingSemicolon(sql: string): string {
-    return sql.trim().replace(/;$/, '');
-  }
-
-  protected wrapSetOperand(sql: string): string {
-    const trimmed = this.stripTrailingSemicolon(sql);
-    return `(${trimmed})`;
-  }
+
+  protected compileHaving(ast: SelectQueryNode, ctx: CompilerContext): string {
+    if (!ast.having) return '';
+    return ` HAVING ${this.compileExpression(ast.having, ctx)}`;
+  }
+
+  protected stripTrailingSemicolon(sql: string): string {
+    return sql.trim().replace(/;$/, '');
+  }
+
+  protected wrapSetOperand(sql: string): string {
+    const trimmed = this.stripTrailingSemicolon(sql);
+    return `(${trimmed})`;
+  }
+
+  protected renderOrderByNulls(order: OrderByNode): string | undefined {
+    return order.nulls ? ` NULLS ${order.nulls}` : '';
+  }
+
+  protected renderOrderByCollation(order: OrderByNode): string | undefined {
+    return order.collation ? ` COLLATE ${order.collation}` : '';
+  }
 }