metal-orm 1.1.3 → 1.1.4

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

@@ -1,15 +1,16 @@
 import { CompilerContext, Dialect } from '../abstract.js';
-import {
-  SelectQueryNode,
-  InsertQueryNode,
-  UpdateQueryNode,
-  DeleteQueryNode,
-  InsertSourceNode,
-  TableSourceNode,
-  DerivedTableNode,
-  FunctionTableNode,
-  OrderByNode,
-  TableNode
+import {
+  SelectQueryNode,
+  InsertQueryNode,
+  UpdateQueryNode,
+  DeleteQueryNode,
+  InsertSourceNode,
+  UpsertClause,
+  TableSourceNode,
+  DerivedTableNode,
+  FunctionTableNode,
+  OrderByNode,
+  TableNode
 } from '../../ast/query.js';
 import { ColumnNode, OperandNode } from '../../ast/expression.js';
 import { FunctionTableFormatter } from './function-table-formatter.js';
@@ -77,35 +78,48 @@ export abstract class SqlDialectBase extends Dialect {
       throw new Error('INSERT queries must specify columns.');
     }
 
-    const table = this.compileTableName(ast.into);
-    const columnList = this.compileInsertColumnList(ast.columns);
-    const source = this.compileInsertSource(ast.source, ctx);
-    const returning = this.compileReturning(ast.returning, ctx);
-    return `INSERT INTO ${table} (${columnList}) ${source}${returning}`;
-  }
+    const table = this.compileTableName(ast.into);
+    const columnList = this.compileInsertColumnList(ast.columns);
+    const source = this.compileInsertSource(ast.source, ctx);
+    const upsert = this.compileUpsertClause(ast, ctx);
+    const returning = this.compileReturning(ast.returning, ctx);
+    return `INSERT INTO ${table} (${columnList}) ${source}${upsert}${returning}`;
+  }
+
+  protected compileUpsertClause(ast: InsertQueryNode, _ctx: CompilerContext): string {
+    void _ctx;
+    if (!ast.onConflict) return '';
+    throw new Error(`UPSERT/ON CONFLICT is not supported by dialect "${this.dialect}".`);
+  }
 
   protected compileReturning(returning: ColumnNode[] | undefined, ctx: CompilerContext): string {
     return this.returningStrategy.compileReturning(returning, ctx);
   }
 
-  private compileInsertSource(source: InsertSourceNode, ctx: CompilerContext): string {
-    if (source.type === 'InsertValues') {
-      if (!source.rows.length) {
-        throw new Error('INSERT ... VALUES requires at least one row.');
-      }
+  protected compileInsertSource(source: InsertSourceNode, ctx: CompilerContext): string {
+    if (source.type === 'InsertValues') {
+      if (!source.rows.length) {
+        throw new Error('INSERT ... VALUES requires at least one row.');
+      }
       const values = source.rows
         .map(row => `(${row.map(value => this.compileOperand(value, ctx)).join(', ')})`)
         .join(', ');
       return `VALUES ${values}`;
     }
 
-    const normalized = this.normalizeSelectAst(source.query);
-    return this.compileSelectAst(normalized, ctx).trim();
-  }
-
-  private compileInsertColumnList(columns: ColumnNode[]): string {
-    return columns.map(column => this.quoteIdentifier(column.name)).join(', ');
-  }
+    const normalized = this.normalizeSelectAst(source.query);
+    return this.compileSelectAst(normalized, ctx).trim();
+  }
+
+  protected compileInsertColumnList(columns: ColumnNode[]): string {
+    return columns.map(column => this.quoteIdentifier(column.name)).join(', ');
+  }
+
+  protected ensureConflictColumns(clause: UpsertClause, message: string): void {
+    if (!clause.target.columns.length) {
+      throw new Error(message);
+    }
+  }
 
   private compileSelectCore(ast: SelectQueryNode, ctx: CompilerContext): string {
     const columns = this.compileSelectColumns(ast, ctx);