metal-orm 1.0.3 → 1.0.5

package/src/builder/relation-service.ts

@@ -1,6 +1,6 @@
 import { TableDef } from '../schema/table';
 import { ColumnDef } from '../schema/column';
-import { RelationDef } from '../schema/relation';
+import { RelationDef, RelationKinds, BelongsToManyRelation } from '../schema/relation';
 import { SelectQueryNode } from '../ast/query';
 import {
   ColumnNode,
@@ -13,11 +13,16 @@ import { QueryAstService } from './query-ast-service';
 import { findPrimaryKey } from './hydration-planner';
 import { RelationProjectionHelper } from './relation-projection-helper';
 import type { RelationResult } from './relation-projection-helper';
-import { buildRelationJoinCondition, buildRelationCorrelation } from './relation-conditions';
+import {
+  buildRelationJoinCondition,
+  buildRelationCorrelation,
+  buildBelongsToManyJoins
+} from './relation-conditions';
 import { JoinKind, JOIN_KINDS } from '../constants/sql';
-import { RelationIncludeJoinKind } from './relation-types';
+import { RelationIncludeOptions } from './relation-types';
 import { createJoinNode } from '../utils/join-node';
 import { makeRelationAlias } from '../utils/relation-alias';
+import { buildDefaultPivotColumns } from './relation-utils';
 
 /**
  * Service for handling relation operations (joins, includes, etc.)
@@ -82,10 +87,7 @@ export class RelationService {
    * @param options - Options for relation inclusion
    * @returns Relation result with updated state and hydration
    */
-  include(
-    relationName: string,
-    options?: { columns?: string[]; aliasPrefix?: string; filter?: ExpressionNode; joinKind?: RelationIncludeJoinKind }
-  ): RelationResult {
+  include(relationName: string, options?: RelationIncludeOptions): RelationResult {
     let state = this.state;
     let hydration = this.hydration;
 
@@ -106,16 +108,66 @@ export class RelationService {
       ? options.columns
       : Object.keys(relation.target.columns);
 
-    const relationSelection = targetColumns.reduce((acc, key) => {
-      const def = (relation.target.columns as any)[key];
-      if (!def) {
-        throw new Error(`Column '${key}' not found on relation '${relationName}'`);
-      }
-      acc[makeRelationAlias(aliasPrefix, key)] = def;
-      return acc;
-    }, {} as Record<string, ColumnDef>);
+    const buildTypedSelection = (
+      columns: Record<string, ColumnDef>,
+      prefix: string,
+      keys: string[],
+      missingMsg: (col: string) => string
+    ) : Record<string, ColumnDef> => {
+      return keys.reduce((acc, key) => {
+        const def = columns[key];
+        if (!def) {
+          throw new Error(missingMsg(key));
+        }
+        acc[makeRelationAlias(prefix, key)] = def;
+        return acc;
+      }, {} as Record<string, ColumnDef>);
+    };
+
+    const targetSelection = buildTypedSelection(
+      relation.target.columns as Record<string, ColumnDef>,
+      aliasPrefix,
+      targetColumns,
+      key => `Column '${key}' not found on relation '${relationName}'`
+    );
+
+    if (relation.type !== RelationKinds.BelongsToMany) {
+      const relationSelectionResult = this.selectColumns(state, hydration, targetSelection);
+      state = relationSelectionResult.state;
+      hydration = relationSelectionResult.hydration;
 
-    const relationSelectionResult = this.selectColumns(state, hydration, relationSelection);
+      hydration = hydration.onRelationIncluded(
+        state,
+        relation,
+        relationName,
+        aliasPrefix,
+        targetColumns
+      );
+
+      return { state, hydration };
+    }
+
+    const many = relation as BelongsToManyRelation;
+    const pivotAliasPrefix = options?.pivot?.aliasPrefix ?? `${aliasPrefix}_pivot`;
+    const pivotPk = many.pivotPrimaryKey || findPrimaryKey(many.pivotTable);
+    const pivotColumns =
+      options?.pivot?.columns ??
+      many.defaultPivotColumns ??
+      buildDefaultPivotColumns(many, pivotPk);
+
+    const pivotSelection = buildTypedSelection(
+      many.pivotTable.columns as Record<string, ColumnDef>,
+      pivotAliasPrefix,
+      pivotColumns,
+      key => `Column '${key}' not found on pivot table '${many.pivotTable.name}'`
+    );
+
+    const combinedSelection = {
+      ...targetSelection,
+      ...pivotSelection
+    };
+
+    const relationSelectionResult = this.selectColumns(state, hydration, combinedSelection);
     state = relationSelectionResult.state;
     hydration = relationSelectionResult.hydration;
 
@@ -124,7 +176,8 @@ export class RelationService {
       relation,
       relationName,
       aliasPrefix,
-      targetColumns
+      targetColumns,
+      { aliasPrefix: pivotAliasPrefix, columns: pivotColumns }
     );
 
     return { state, hydration };
@@ -167,8 +220,18 @@ export class RelationService {
     extraCondition?: ExpressionNode
   ): SelectQueryState {
     const relation = this.getRelation(relationName);
-    const condition = buildRelationJoinCondition(this.table, relation, extraCondition);
+    if (relation.type === RelationKinds.BelongsToMany) {
+      const joins = buildBelongsToManyJoins(
+        this.table,
+        relationName,
+        relation as BelongsToManyRelation,
+        joinKind,
+        extraCondition
+      );
+      return joins.reduce((current, join) => this.astService(current).withJoin(join), state);
+    }
 
+    const condition = buildRelationJoinCondition(this.table, relation, extraCondition);
     const joinNode = createJoinNode(joinKind, relation.target.name, condition, relationName);
 
     return this.astService(state).withJoin(joinNode);

package/src/builder/relation-types.ts

@@ -1,6 +1,21 @@
+import { ExpressionNode } from '../ast/expression';
 import { JOIN_KINDS } from '../constants/sql';
 
 /**
  * Join kinds allowed when including a relation using `.include(...)`.
  */
 export type RelationIncludeJoinKind = typeof JOIN_KINDS.LEFT | typeof JOIN_KINDS.INNER;
+
+/**
+ * Options for including a relation in a query
+ */
+export interface RelationIncludeOptions {
+  columns?: string[];
+  aliasPrefix?: string;
+  filter?: ExpressionNode;
+  joinKind?: RelationIncludeJoinKind;
+  pivot?: {
+    columns?: string[];
+    aliasPrefix?: string;
+  };
+}

package/src/builder/relation-utils.ts

@@ -0,0 +1,12 @@
+import { BelongsToManyRelation } from '../schema/relation';
+
+/**
+ * Builds a default set of pivot columns, excluding keys used for joins.
+ */
+export const buildDefaultPivotColumns = (
+  rel: BelongsToManyRelation,
+  pivotPk: string
+): string[] => {
+  const excluded = new Set([pivotPk, rel.pivotForeignKeyToRoot, rel.pivotForeignKeyToTarget]);
+  return Object.keys(rel.pivotTable.columns).filter(col => !excluded.has(col));
+};

package/src/builder/select.ts

@@ -26,7 +26,8 @@ import { CteManager } from './operations/cte-manager';
 import { JoinManager } from './operations/join-manager';
 import { FilterManager } from './operations/filter-manager';
 import { PaginationManager } from './operations/pagination-manager';
-import { RelationManager, RelationIncludeOptions } from './operations/relation-manager';
+import { RelationManager } from './operations/relation-manager';
+import { RelationIncludeOptions } from './relation-types';
 import { JOIN_KINDS, JoinKind, ORDER_DIRECTIONS, OrderDirection } from '../constants/sql';
 
 /**

package/src/builder/update-query-state.ts

@@ -0,0 +1,59 @@
+import { TableDef } from '../schema/table';
+import { ColumnNode, ExpressionNode, valueToOperand } from '../ast/expression';
+import { TableNode, UpdateQueryNode, UpdateAssignmentNode } from '../ast/query';
+
+const createTableNode = (table: TableDef): TableNode => ({
+  type: 'Table',
+  name: table.name
+});
+
+/**
+ * Immutable state for UPDATE queries
+ */
+export class UpdateQueryState {
+  public readonly table: TableDef;
+  public readonly ast: UpdateQueryNode;
+
+  constructor(table: TableDef, ast?: UpdateQueryNode) {
+    this.table = table;
+    this.ast = ast ?? {
+      type: 'UpdateQuery',
+      table: createTableNode(table),
+      set: []
+    };
+  }
+
+  private clone(nextAst: UpdateQueryNode): UpdateQueryState {
+    return new UpdateQueryState(this.table, nextAst);
+  }
+
+  withSet(values: Record<string, unknown>): UpdateQueryState {
+    const assignments: UpdateAssignmentNode[] = Object.entries(values).map(([column, value]) => ({
+      column: {
+        type: 'Column',
+        table: this.table.name,
+        name: column
+      },
+      value: valueToOperand(value)
+    }));
+
+    return this.clone({
+      ...this.ast,
+      set: assignments
+    });
+  }
+
+  withWhere(expr: ExpressionNode): UpdateQueryState {
+    return this.clone({
+      ...this.ast,
+      where: expr
+    });
+  }
+
+  withReturning(columns: ColumnNode[]): UpdateQueryState {
+    return this.clone({
+      ...this.ast,
+      returning: [...columns]
+    });
+  }
+}

package/src/builder/update.ts

@@ -0,0 +1,61 @@
+import { TableDef } from '../schema/table';
+import { ColumnDef } from '../schema/column';
+import { ColumnNode, ExpressionNode } from '../ast/expression';
+import { CompiledQuery, UpdateCompiler } from '../dialect/abstract';
+import { UpdateQueryNode } from '../ast/query';
+import { UpdateQueryState } from './update-query-state';
+
+const buildColumnNode = (table: TableDef, column: ColumnDef | ColumnNode): ColumnNode => {
+  if ((column as ColumnNode).type === 'Column') {
+    return column as ColumnNode;
+  }
+  const def = column as ColumnDef;
+  return {
+    type: 'Column',
+    table: def.table || table.name,
+    name: def.name
+  };
+};
+
+/**
+ * Builder for UPDATE queries
+ */
+export class UpdateQueryBuilder<T> {
+  private readonly table: TableDef;
+  private readonly state: UpdateQueryState;
+
+  constructor(table: TableDef, state?: UpdateQueryState) {
+    this.table = table;
+    this.state = state ?? new UpdateQueryState(table);
+  }
+
+  private clone(state: UpdateQueryState): UpdateQueryBuilder<T> {
+    return new UpdateQueryBuilder(this.table, state);
+  }
+
+  set(values: Record<string, unknown>): UpdateQueryBuilder<T> {
+    return this.clone(this.state.withSet(values));
+  }
+
+  where(expr: ExpressionNode): UpdateQueryBuilder<T> {
+    return this.clone(this.state.withWhere(expr));
+  }
+
+  returning(...columns: (ColumnDef | ColumnNode)[]): UpdateQueryBuilder<T> {
+    if (!columns.length) return this;
+    const nodes = columns.map(column => buildColumnNode(this.table, column));
+    return this.clone(this.state.withReturning(nodes));
+  }
+
+  compile(compiler: UpdateCompiler): CompiledQuery {
+    return compiler.compileUpdate(this.state.ast);
+  }
+
+  toSql(compiler: UpdateCompiler): string {
+    return this.compile(compiler).sql;
+  }
+
+  getAST(): UpdateQueryNode {
+    return this.state.ast;
+  }
+}

package/src/dialect/abstract.ts

@@ -1,4 +1,4 @@
-import { SelectQueryNode } from '../ast/query';
+import { SelectQueryNode, InsertQueryNode, UpdateQueryNode, DeleteQueryNode } from '../ast/query';
 import {
   ExpressionNode,
   BinaryExpressionNode,
@@ -30,39 +30,91 @@ export interface CompilerContext {
 /**
  * Result of SQL compilation
  */
-export interface CompiledQuery {
-  /** Generated SQL string */
-  sql: string;
-  /** Parameters for the query */
-  params: unknown[];
-}
-
-/**
- * Abstract base class for SQL dialect implementations
- */
-export abstract class Dialect {
+export interface CompiledQuery {
+  /** Generated SQL string */
+  sql: string;
+  /** Parameters for the query */
+  params: unknown[];
+}
+
+export interface SelectCompiler {
+  compileSelect(ast: SelectQueryNode): CompiledQuery;
+}
+
+export interface InsertCompiler {
+  compileInsert(ast: InsertQueryNode): CompiledQuery;
+}
+
+export interface UpdateCompiler {
+  compileUpdate(ast: UpdateQueryNode): CompiledQuery;
+}
+
+export interface DeleteCompiler {
+  compileDelete(ast: DeleteQueryNode): CompiledQuery;
+}
+
+/**
+ * Abstract base class for SQL dialect implementations
+ */
+export abstract class Dialect
+  implements SelectCompiler, InsertCompiler, UpdateCompiler, DeleteCompiler
+{
   /**
    * Compiles a SELECT query AST to SQL
    * @param ast - Query AST to compile
    * @returns Compiled query with SQL and parameters
    */
-  compileSelect(ast: SelectQueryNode): CompiledQuery {
-    const ctx = this.createCompilerContext();
-    const rawSql = this.compileSelectAst(ast, ctx).trim();
-    const sql = rawSql.endsWith(';') ? rawSql : `${rawSql};`;
-    return {
-      sql,
-      params: [...ctx.params]
-    };
-  }
-
-  /**
-   * Compiles SELECT query AST to SQL (to be implemented by concrete dialects)
-   * @param ast - Query AST
-   * @param ctx - Compiler context
-   * @returns SQL string
-   */
-  protected abstract compileSelectAst(ast: SelectQueryNode, ctx: CompilerContext): string;
+  compileSelect(ast: SelectQueryNode): CompiledQuery {
+    const ctx = this.createCompilerContext();
+    const rawSql = this.compileSelectAst(ast, ctx).trim();
+    const sql = rawSql.endsWith(';') ? rawSql : `${rawSql};`;
+    return {
+      sql,
+      params: [...ctx.params]
+    };
+  }
+
+  compileInsert(ast: InsertQueryNode): CompiledQuery {
+    const ctx = this.createCompilerContext();
+    const rawSql = this.compileInsertAst(ast, ctx).trim();
+    const sql = rawSql.endsWith(';') ? rawSql : `${rawSql};`;
+    return {
+      sql,
+      params: [...ctx.params]
+    };
+  }
+
+  compileUpdate(ast: UpdateQueryNode): CompiledQuery {
+    const ctx = this.createCompilerContext();
+    const rawSql = this.compileUpdateAst(ast, ctx).trim();
+    const sql = rawSql.endsWith(';') ? rawSql : `${rawSql};`;
+    return {
+      sql,
+      params: [...ctx.params]
+    };
+  }
+
+  compileDelete(ast: DeleteQueryNode): CompiledQuery {
+    const ctx = this.createCompilerContext();
+    const rawSql = this.compileDeleteAst(ast, ctx).trim();
+    const sql = rawSql.endsWith(';') ? rawSql : `${rawSql};`;
+    return {
+      sql,
+      params: [...ctx.params]
+    };
+  }
+
+  /**
+   * Compiles SELECT query AST to SQL (to be implemented by concrete dialects)
+   * @param ast - Query AST
+   * @param ctx - Compiler context
+   * @returns SQL string
+   */
+  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;
 
   /**
    * Quotes an SQL identifier (to be implemented by concrete dialects)
@@ -77,10 +129,18 @@ export abstract class Dialect {
    * @param ctx - Compiler context
    * @returns SQL WHERE clause or empty string
    */
-  protected compileWhere(where: ExpressionNode | undefined, ctx: CompilerContext): string {
-    if (!where) return '';
-    return ` WHERE ${this.compileExpression(where, ctx)}`;
-  }
+  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 {
+    if (!returning || returning.length === 0) return '';
+    throw new Error('RETURNING is not supported by this dialect.');
+  }
 
   /**
    * Generates subquery for EXISTS expressions
@@ -163,13 +223,13 @@ export abstract class Dialect {
    * @param ctx - Compiler context
    * @returns Compiled SQL expression
    */
-  protected 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.constructor.name}`);
-    }
-    return compiler(node, ctx);
-  }
+  protected 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.constructor.name}`);
+    }
+    return compiler(node, ctx);
+  }
 
   /**
    * Compiles an operand node
@@ -177,13 +237,13 @@ export abstract class Dialect {
    * @param ctx - Compiler context
    * @returns Compiled SQL operand
    */
-  protected 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.constructor.name}`);
-    }
-    return compiler(node, ctx);
-  }
+  protected 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.constructor.name}`);
+    }
+    return compiler(node, ctx);
+  }
 
   private registerDefaultExpressionCompilers(): void {
     this.registerExpressionCompiler('BinaryExpression', (binary: BinaryExpressionNode, ctx) => {

package/src/dialect/mssql/index.ts

@@ -1,6 +1,6 @@
-import { CompilerContext, Dialect } from '../abstract';
-import { SelectQueryNode } from '../../ast/query';
-import { JsonPathNode } from '../../ast/expression';
+import { CompilerContext, Dialect } from '../abstract';
+import { SelectQueryNode, InsertQueryNode, UpdateQueryNode, DeleteQueryNode } from '../../ast/query';
+import { JsonPathNode } from '../../ast/expression';
 
 /**
  * Microsoft SQL Server dialect implementation
@@ -48,7 +48,7 @@ export class SqlServerDialect extends Dialect {
    * @param ctx - Compiler context
    * @returns SQL Server SQL string
    */
-  protected compileSelectAst(ast: SelectQueryNode, ctx: CompilerContext): string {
+  protected compileSelectAst(ast: SelectQueryNode, ctx: CompilerContext): string {
     const columns = ast.columns.map(c => {
       let expr = '';
       if (c.type === 'Function') {
@@ -111,6 +111,31 @@ export class SqlServerDialect extends Dialect {
       }).join(', ') + ' '
       : '';
 
-    return `${ctes}SELECT ${distinct}${columns} FROM ${from}${joins ? ' ' + joins : ''}${whereClause}${groupBy}${having}${orderBy};`;
-  }
+    return `${ctes}SELECT ${distinct}${columns} FROM ${from}${joins ? ' ' + joins : ''}${whereClause}${groupBy}${having}${orderBy};`;
+  }
+
+  protected compileInsertAst(ast: InsertQueryNode, ctx: CompilerContext): string {
+    const table = this.quoteIdentifier(ast.into.name);
+    const columnList = ast.columns.map(column => `${this.quoteIdentifier(column.table)}.${this.quoteIdentifier(column.name)}`).join(', ');
+    const values = ast.values.map(row => `(${row.map(value => this.compileOperand(value, ctx)).join(', ')})`).join(', ');
+    return `INSERT INTO ${table} (${columnList}) VALUES ${values};`;
+  }
+
+  protected compileUpdateAst(ast: UpdateQueryNode, ctx: CompilerContext): string {
+    const table = this.quoteIdentifier(ast.table.name);
+    const assignments = ast.set.map(assignment => {
+      const col = assignment.column;
+      const target = `${this.quoteIdentifier(col.table)}.${this.quoteIdentifier(col.name)}`;
+      const value = this.compileOperand(assignment.value, ctx);
+      return `${target} = ${value}`;
+    }).join(', ');
+    const whereClause = this.compileWhere(ast.where, ctx);
+    return `UPDATE ${table} SET ${assignments}${whereClause};`;
+  }
+
+  protected compileDeleteAst(ast: DeleteQueryNode, ctx: CompilerContext): string {
+    const table = this.quoteIdentifier(ast.from.name);
+    const whereClause = this.compileWhere(ast.where, ctx);
+    return `DELETE FROM ${table}${whereClause};`;
+  }
 }

package/src/dialect/mysql/index.ts

@@ -1,6 +1,6 @@
-import { CompilerContext, Dialect } from '../abstract';
-import { SelectQueryNode } from '../../ast/query';
-import { JsonPathNode } from '../../ast/expression';
+import { CompilerContext, Dialect } from '../abstract';
+import { SelectQueryNode, InsertQueryNode, UpdateQueryNode, DeleteQueryNode } from '../../ast/query';
+import { JsonPathNode } from '../../ast/expression';
 
 /**
  * MySQL dialect implementation
@@ -39,7 +39,7 @@ export class MySqlDialect extends Dialect {
    * @param ctx - Compiler context
    * @returns MySQL SQL string
    */
-  protected compileSelectAst(ast: SelectQueryNode, ctx: CompilerContext): string {
+  protected compileSelectAst(ast: SelectQueryNode, ctx: CompilerContext): string {
     const columns = ast.columns.map(c => {
       let expr = '';
       if (c.type === 'Function') {
@@ -98,6 +98,31 @@ export class MySqlDialect extends Dialect {
       })()
       : '';
 
-    return `${ctes}SELECT ${distinct}${columns} FROM ${from}${joins ? ' ' + joins : ''}${whereClause}${groupBy}${having}${orderBy}${limit}${offset};`;
-  }
+    return `${ctes}SELECT ${distinct}${columns} FROM ${from}${joins ? ' ' + joins : ''}${whereClause}${groupBy}${having}${orderBy}${limit}${offset};`;
+  }
+
+  protected compileInsertAst(ast: InsertQueryNode, ctx: CompilerContext): string {
+    const table = this.quoteIdentifier(ast.into.name);
+    const columnList = ast.columns.map(column => `${this.quoteIdentifier(column.table)}.${this.quoteIdentifier(column.name)}`).join(', ');
+    const values = ast.values.map(row => `(${row.map(value => this.compileOperand(value, ctx)).join(', ')})`).join(', ');
+    return `INSERT INTO ${table} (${columnList}) VALUES ${values};`;
+  }
+
+  protected compileUpdateAst(ast: UpdateQueryNode, ctx: CompilerContext): string {
+    const table = this.quoteIdentifier(ast.table.name);
+    const assignments = ast.set.map(assignment => {
+      const col = assignment.column;
+      const target = `${this.quoteIdentifier(col.table)}.${this.quoteIdentifier(col.name)}`;
+      const value = this.compileOperand(assignment.value, ctx);
+      return `${target} = ${value}`;
+    }).join(', ');
+    const whereClause = this.compileWhere(ast.where, ctx);
+    return `UPDATE ${table} SET ${assignments}${whereClause};`;
+  }
+
+  protected compileDeleteAst(ast: DeleteQueryNode, ctx: CompilerContext): string {
+    const table = this.quoteIdentifier(ast.from.name);
+    const whereClause = this.compileWhere(ast.where, ctx);
+    return `DELETE FROM ${table}${whereClause};`;
+  }
 }

package/src/dialect/postgres/index.ts

@@ -1,6 +1,6 @@
-import { CompilerContext, Dialect } from '../abstract';
-import { SelectQueryNode } from '../../ast/query';
-import { JsonPathNode } from '../../ast/expression';
+import { CompilerContext, Dialect } from '../abstract';
+import { SelectQueryNode, InsertQueryNode, UpdateQueryNode, DeleteQueryNode } from '../../ast/query';
+import { JsonPathNode, ColumnNode } from '../../ast/expression';
 
 /**
  * PostgreSQL dialect implementation
@@ -39,7 +39,7 @@ export class PostgresDialect extends Dialect {
    * @param ctx - Compiler context
    * @returns PostgreSQL SQL string
    */
-  protected compileSelectAst(ast: SelectQueryNode, ctx: CompilerContext): string {
+  protected compileSelectAst(ast: SelectQueryNode, ctx: CompilerContext): string {
     const columns = ast.columns.map(c => {
       let expr = '';
       if (c.type === 'Function') {
@@ -98,6 +98,45 @@ export class PostgresDialect extends Dialect {
       })()
       : '';
 
-    return `${ctes}SELECT ${distinct}${columns} FROM ${from}${joins ? ' ' + joins : ''}${whereClause}${groupBy}${having}${orderBy}${limit}${offset};`;
-  }
+    return `${ctes}SELECT ${distinct}${columns} FROM ${from}${joins ? ' ' + joins : ''}${whereClause}${groupBy}${having}${orderBy}${limit}${offset};`;
+  }
+
+  protected compileInsertAst(ast: InsertQueryNode, ctx: CompilerContext): string {
+    const table = this.quoteIdentifier(ast.into.name);
+    const columnList = ast.columns.map(column => `${this.quoteIdentifier(column.table)}.${this.quoteIdentifier(column.name)}`).join(', ');
+    const values = ast.values.map(row => `(${row.map(value => this.compileOperand(value, ctx)).join(', ')})`).join(', ');
+    const returning = this.compileReturning(ast.returning, ctx);
+    return `INSERT INTO ${table} (${columnList}) VALUES ${values}${returning};`;
+  }
+
+  protected compileUpdateAst(ast: UpdateQueryNode, ctx: CompilerContext): string {
+    const table = this.quoteIdentifier(ast.table.name);
+    const assignments = ast.set.map(assignment => {
+      const col = assignment.column;
+      const target = `${this.quoteIdentifier(col.table)}.${this.quoteIdentifier(col.name)}`;
+      const value = this.compileOperand(assignment.value, ctx);
+      return `${target} = ${value}`;
+    }).join(', ');
+    const whereClause = this.compileWhere(ast.where, ctx);
+    const returning = this.compileReturning(ast.returning, ctx);
+    return `UPDATE ${table} SET ${assignments}${whereClause}${returning};`;
+  }
+
+  protected compileDeleteAst(ast: DeleteQueryNode, ctx: CompilerContext): string {
+    const table = this.quoteIdentifier(ast.from.name);
+    const whereClause = this.compileWhere(ast.where, ctx);
+    const returning = this.compileReturning(ast.returning, ctx);
+    return `DELETE FROM ${table}${whereClause}${returning};`;
+  }
+
+  protected compileReturning(returning: ColumnNode[] | undefined, ctx: CompilerContext): string {
+    if (!returning || returning.length === 0) return '';
+    const columns = returning
+      .map(column => {
+        const tablePart = column.table ? `${this.quoteIdentifier(column.table)}.` : '';
+        return `${tablePart}${this.quoteIdentifier(column.name)}`;
+      })
+      .join(', ');
+    return ` RETURNING ${columns}`;
+  }
 }