metal-orm 1.0.40 → 1.0.42

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metal-orm",
-  "version": "1.0.40",
+  "version": "1.0.42",
   "type": "module",
   "types": "./dist/index.d.ts",
   "engines": {

package/src/codegen/typescript.ts

@@ -293,9 +293,13 @@ export class TypeScriptGenerator implements ExpressionVisitor<string>, OperandVi
    */
   private printInExpression(inExpr: InExpressionNode): string {
     const left = this.printOperand(inExpr.left);
-    const values = inExpr.right.map(v => this.printOperand(v)).join(', ');
     const fn = this.mapOp(inExpr.operator);
-    return `${fn}(${left}, [${values}])`;
+    if (Array.isArray(inExpr.right)) {
+      const values = inExpr.right.map(v => this.printOperand(v)).join(', ');
+      return `${fn}(${left}, [${values}])`;
+    }
+    const subquery = this.inlineChain(this.buildSelectLines(inExpr.right.query));
+    return `${fn}(${left}, (${subquery}))`;
   }
 
   /**

package/src/core/ast/expression-builders.ts

@@ -15,6 +15,8 @@ import {
   NullExpressionNode,
   InExpressionNode,
   ExistsExpressionNode,
+  InExpressionRight,
+  ScalarSubqueryNode,
   BetweenExpressionNode,
   isOperandNode,
   AliasRefNode,
@@ -65,6 +67,19 @@ const toOperand = (val: OperandNode | ColumnRef | LiteralValue): OperandNode =>
   return toNode(val);
 };
 
+export type SelectQueryInput = SelectQueryNode | { getAST(): SelectQueryNode };
+
+const hasQueryAst = (value: SelectQueryInput): value is { getAST(): SelectQueryNode } =>
+  typeof (value as { getAST?: unknown }).getAST === 'function';
+
+const resolveSelectQueryNode = (query: SelectQueryInput): SelectQueryNode =>
+  hasQueryAst(query) ? query.getAST() : query;
+
+const toScalarSubqueryNode = (query: SelectQueryInput): ScalarSubqueryNode => ({
+  type: 'ScalarSubquery',
+  query: resolveSelectQueryNode(query)
+});
+
 export const columnOperand = (col: ColumnRef | ColumnNode): ColumnNode => toNode(col) as ColumnNode;
 /**
  * Marks a column reference as an outer-scope reference for correlated subqueries.
@@ -222,12 +237,12 @@ export const isNotNull = (left: OperandNode | ColumnRef): NullExpressionNode =>
 const createInExpression = (
   operator: 'IN' | 'NOT IN',
   left: OperandNode | ColumnRef,
-  values: (string | number | LiteralNode)[]
+  right: InExpressionRight
 ): InExpressionNode => ({
   type: 'InExpression',
   left: toNode(left),
   operator,
-  right: values.map(v => toOperand(v))
+  right
 });
 
 /**
@@ -237,7 +252,7 @@ const createInExpression = (
  * @returns IN expression node
  */
 export const inList = (left: OperandNode | ColumnRef, values: (string | number | LiteralNode)[]): InExpressionNode =>
-  createInExpression('IN', left, values);
+  createInExpression('IN', left, values.map(v => toOperand(v)));
 
 /**
  * Creates a NOT IN expression (value NOT IN list)
@@ -246,7 +261,13 @@ export const inList = (left: OperandNode | ColumnRef, values: (string | number |
  * @returns NOT IN expression node
  */
 export const notInList = (left: OperandNode | ColumnRef, values: (string | number | LiteralNode)[]): InExpressionNode =>
-  createInExpression('NOT IN', left, values);
+  createInExpression('NOT IN', left, values.map(v => toOperand(v)));
+
+export const inSubquery = (left: OperandNode | ColumnRef, subquery: SelectQueryInput): InExpressionNode =>
+  createInExpression('IN', left, toScalarSubqueryNode(subquery));
+
+export const notInSubquery = (left: OperandNode | ColumnRef, subquery: SelectQueryInput): InExpressionNode =>
+  createInExpression('NOT IN', left, toScalarSubqueryNode(subquery));
 
 const createBetweenExpression = (
   operator: 'BETWEEN' | 'NOT BETWEEN',

package/src/core/ast/expression-nodes.ts

@@ -80,6 +80,8 @@ export interface ScalarSubqueryNode {
   alias?: string;
 }
 
+export type InExpressionRight = OperandNode[] | ScalarSubqueryNode;
+
 /**
  * AST node representing a CASE expression
  */
@@ -201,7 +203,7 @@ export interface InExpressionNode {
   /** IN/NOT IN operator */
   operator: 'IN' | 'NOT IN';
   /** Values to check against */
-  right: OperandNode[];
+  right: InExpressionRight;
 }
 
 /**

package/src/core/ast/expression.ts

@@ -1,7 +1,7 @@
-export * from './expression-nodes.js';
+export * from './expression-nodes.js';
 export * from './expression-builders.js';
 export * from './window-functions.js';
 export * from './aggregate-functions.js';
 export * from './expression-visitor.js';
-export * from './types.js';
+export type { ColumnRef, TableRef as AstTableRef } from './types.js';
 export * from './adapters.js';

package/src/core/ast/query.ts

@@ -144,14 +144,28 @@ export interface SelectQueryNode {
   setOps?: SetOperationNode[];
 }
 
+export interface InsertValuesSourceNode {
+  type: 'InsertValues';
+  /** Rows of values for INSERT rows */
+  rows: OperandNode[][];
+}
+
+export interface InsertSelectSourceNode {
+  type: 'InsertSelect';
+  /** SELECT query providing rows */
+  query: SelectQueryNode;
+}
+
+export type InsertSourceNode = InsertValuesSourceNode | InsertSelectSourceNode;
+
 export interface InsertQueryNode {
   type: 'InsertQuery';
   /** Target table */
   into: TableNode;
   /** Column order for inserted values */
   columns: ColumnNode[];
-  /** Rows of values to insert */
-  values: OperandNode[][];
+  /** Source of inserted rows (either literal values or a SELECT query) */
+  source: InsertSourceNode;
   /** Optional RETURNING clause */
   returning?: ColumnNode[];
 }
@@ -167,6 +181,10 @@ export interface UpdateQueryNode {
   type: 'UpdateQuery';
   /** Table being updated */
   table: TableNode;
+  /** Optional FROM clause for multi-table updates */
+  from?: TableSourceNode;
+  /** Optional joins applied to the FROM/USING tables */
+  joins?: JoinNode[];
   /** Assignments for SET clause */
   set: UpdateAssignmentNode[];
   /** Optional WHERE clause */
@@ -179,6 +197,10 @@ export interface DeleteQueryNode {
   type: 'DeleteQuery';
   /** Table to delete from */
   from: TableNode;
+  /** Optional USING clause for multi-table deletes */
+  using?: TableSourceNode;
+  /** Optional joins applied to the USING clause */
+  joins?: JoinNode[];
   /** Optional WHERE clause */
   where?: ExpressionNode;
   /** Optional RETURNING clause */

package/src/core/dialect/abstract.ts

@@ -408,8 +408,12 @@ export abstract class Dialect
 
     this.registerExpressionCompiler('InExpression', (inExpr: InExpressionNode, ctx) => {
       const left = this.compileOperand(inExpr.left, ctx);
-      const values = inExpr.right.map(v => this.compileOperand(v, ctx)).join(', ');
-      return `${left} ${inExpr.operator} (${values})`;
+      if (Array.isArray(inExpr.right)) {
+        const values = inExpr.right.map(v => this.compileOperand(v, ctx)).join(', ');
+        return `${left} ${inExpr.operator} (${values})`;
+      }
+      const subquerySql = this.compileSelectAst(inExpr.right.query, ctx).trim().replace(/;$/, '');
+      return `${left} ${inExpr.operator} (${subquerySql})`;
     });
 
     this.registerExpressionCompiler('ExistsExpression', (existsExpr: ExistsExpressionNode, ctx) => {

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

@@ -1,22 +1,19 @@
-import { SelectQueryNode } from '../../ast/query.js';
 import { CompilerContext } from '../abstract.js';
+import { JoinNode } from '../../ast/join.js';
 
 /**
  * Compiler for JOIN clauses in SELECT statements.
  * Handles compilation of all join types (INNER, LEFT, RIGHT, FULL, CROSS).
  */
 export class JoinCompiler {
-  /**
-   * Compiles all JOIN clauses from a SELECT query AST.
-   * @param ast - The SELECT query AST containing join definitions.
-   * @param ctx - The compiler context for expression compilation.
-   * @param compileFrom - Function to compile table sources (tables or subqueries).
-   * @param compileExpression - Function to compile join condition expressions.
-   * @returns SQL JOIN clauses (e.g., " LEFT JOIN table ON condition") or empty string if no joins.
-   */
-  static compileJoins(ast: SelectQueryNode, ctx: CompilerContext, compileFrom: (from: any, ctx: CompilerContext) => string, compileExpression: (expr: any, ctx: CompilerContext) => string): string {
-    if (!ast.joins || ast.joins.length === 0) return '';
-    const parts = ast.joins.map(j => {
+  static compileJoins(
+    joins: JoinNode[] | undefined,
+    ctx: CompilerContext,
+    compileFrom: (from: any, ctx: CompilerContext) => string,
+    compileExpression: (expr: any, ctx: CompilerContext) => string
+  ): string {
+    if (!joins || joins.length === 0) return '';
+    const parts = joins.map(j => {
       const table = compileFrom(j.table as any, ctx);
       const cond = compileExpression(j.condition, ctx);
       return `${j.kind} JOIN ${table} ON ${cond}`;

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

@@ -1,5 +1,16 @@
 import { CompilerContext, Dialect } from '../abstract.js';
-import { SelectQueryNode, InsertQueryNode, UpdateQueryNode, DeleteQueryNode, TableSourceNode, DerivedTableNode, FunctionTableNode, OrderByNode } from '../../ast/query.js';
+import {
+  SelectQueryNode,
+  InsertQueryNode,
+  UpdateQueryNode,
+  DeleteQueryNode,
+  InsertSourceNode,
+  TableSourceNode,
+  DerivedTableNode,
+  FunctionTableNode,
+  OrderByNode,
+  TableNode
+} from '../../ast/query.js';
 import { ColumnNode } from '../../ast/expression.js';
 import { FunctionTableFormatter } from './function-table-formatter.js';
 import { PaginationStrategy, StandardLimitOffsetPagination } from './pagination-strategy.js';
@@ -57,31 +68,49 @@ export abstract class SqlDialectBase extends Dialect {
   }
 
   protected compileInsertAst(ast: InsertQueryNode, ctx: CompilerContext): string {
+    if (!ast.columns.length) {
+      throw new Error('INSERT queries must specify columns.');
+    }
+
     const table = this.compileTableName(ast.into);
     const columnList = this.compileInsertColumnList(ast.columns);
-    const values = this.compileInsertValues(ast.values, ctx);
+    const source = this.compileInsertSource(ast.source, ctx);
     const returning = this.compileReturning(ast.returning, ctx);
-    return `INSERT INTO ${table} (${columnList}) VALUES ${values}${returning}`;
+    return `INSERT INTO ${table} (${columnList}) ${source}${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 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 compileInsertValues(values: any[][], ctx: CompilerContext): string {
-    return values
-      .map(row => `(${row.map(value => this.compileOperand(value, ctx)).join(', ')})`)
-      .join(', ');
+  private compileInsertColumnList(columns: ColumnNode[]): string {
+    return columns.map(column => this.quoteIdentifier(column.name)).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 joins = JoinCompiler.compileJoins(
+      ast.joins,
+      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);
@@ -96,32 +125,49 @@ export abstract class SqlDialectBase extends Dialect {
   }
 
   protected compileUpdateAst(ast: UpdateQueryNode, ctx: CompilerContext): string {
-    const table = this.compileTableName(ast.table);
-    const assignments = this.compileUpdateAssignments(ast.set, ctx);
+    const target = this.compileTableReference(ast.table);
+    const assignments = this.compileUpdateAssignments(ast.set, ast.table, ctx);
+    const fromClause = this.compileUpdateFromClause(ast, ctx);
     const whereClause = this.compileWhere(ast.where, ctx);
     const returning = this.compileReturning(ast.returning, ctx);
-    return `UPDATE ${table} SET ${assignments}${whereClause}${returning}`;
+    return `UPDATE ${target} SET ${assignments}${fromClause}${whereClause}${returning}`;
   }
 
   private compileUpdateAssignments(
     assignments: { column: ColumnNode; value: any }[],
+    table: TableNode,
     ctx: CompilerContext
   ): string {
     return assignments
       .map(assignment => {
         const col = assignment.column;
-        const target = this.quoteIdentifier(col.name);
+        const target = this.compileQualifiedColumn(col, table);
         const value = this.compileOperand(assignment.value, ctx);
         return `${target} = ${value}`;
       })
       .join(', ');
   }
 
+  protected compileQualifiedColumn(column: ColumnNode, table: TableNode): string {
+    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);
+    }
+
+    return `${this.quoteIdentifier(tableQualifier)}.${this.quoteIdentifier(column.name)}`;
+  }
+
   protected compileDeleteAst(ast: DeleteQueryNode, ctx: CompilerContext): string {
-    const table = this.compileTableName(ast.from);
+    const target = this.compileTableReference(ast.from);
+    const usingClause = this.compileDeleteUsingClause(ast, ctx);
     const whereClause = this.compileWhere(ast.where, ctx);
     const returning = this.compileReturning(ast.returning, ctx);
-    return `DELETE FROM ${table}${whereClause}${returning}`;
+    return `DELETE FROM ${target}${usingClause}${whereClause}${returning}`;
   }
 
   protected formatReturningColumns(returning: ColumnNode[]): string {
@@ -180,13 +226,48 @@ export abstract class SqlDialectBase extends Dialect {
     return table.alias ? `${base} AS ${this.quoteIdentifier(table.alias)}` : base;
   }
 
-  protected compileTableName(table: { name: string; schema?: string }): string {
+  protected compileTableName(table: { name: string; schema?: string; alias?: string }): string {
     if (table.schema) {
       return `${this.quoteIdentifier(table.schema)}.${this.quoteIdentifier(table.name)}`;
     }
     return this.quoteIdentifier(table.name);
   }
 
+  protected compileTableReference(table: { name: string; schema?: string; alias?: string }): string {
+    const base = this.compileTableName(table);
+    return table.alias ? `${base} AS ${this.quoteIdentifier(table.alias)}` : base;
+  }
+
+  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.');
+    }
+    const from = this.compileFrom(ast.from, ctx);
+    const joins = JoinCompiler.compileJoins(
+      ast.joins,
+      ctx,
+      this.compileFrom.bind(this),
+      this.compileExpression.bind(this)
+    );
+    return ` FROM ${from}${joins}`;
+  }
+
+  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.');
+    }
+    const usingTable = this.compileFrom(ast.using, ctx);
+    const joins = JoinCompiler.compileJoins(
+      ast.joins,
+      ctx,
+      this.compileFrom.bind(this),
+      this.compileExpression.bind(this)
+    );
+    return ` USING ${usingTable}${joins}`;
+  }
+
   protected compileHaving(ast: SelectQueryNode, ctx: CompilerContext): string {
     if (!ast.having) return '';
     return ` HAVING ${this.compileExpression(ast.having, ctx)}`;

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

@@ -1,14 +1,21 @@
-import { CompilerContext, Dialect } from '../abstract.js';
-import { SelectQueryNode, InsertQueryNode, UpdateQueryNode, DeleteQueryNode, TableSourceNode, DerivedTableNode, OrderByNode } from '../../ast/query.js';
+import { CompilerContext } from '../abstract.js';
+import {
+  SelectQueryNode,
+  DeleteQueryNode,
+  TableSourceNode,
+  DerivedTableNode,
+  OrderByNode
+} from '../../ast/query.js';
 import { JsonPathNode } from '../../ast/expression.js';
 import { MssqlFunctionStrategy } from './functions.js';
-import { FunctionTableFormatter } from '../base/function-table-formatter.js';
 import { OrderByCompiler } from '../base/orderby-compiler.js';
+import { JoinCompiler } from '../base/join-compiler.js';
+import { SqlDialectBase } from '../base/sql-dialect.js';
 
 /**
  * Microsoft SQL Server dialect implementation
  */
-export class SqlServerDialect extends Dialect {
+export class SqlServerDialect extends SqlDialectBase {
   protected readonly dialect = 'mssql';
   /**
    * Creates a new SqlServerDialect instance
@@ -60,7 +67,7 @@ export class SqlServerDialect extends Dialect {
       ? { ...ast, setOps: undefined, orderBy: undefined, limit: undefined, offset: undefined }
       : ast;
 
-    const baseSelect = this.compileSelectCore(baseAst, ctx);
+    const baseSelect = this.compileSelectCoreForMssql(baseAst, ctx);
 
     if (!hasSetOps) {
       return `${ctes}${baseSelect}`;
@@ -77,35 +84,29 @@ export class SqlServerDialect extends Dialect {
     return `${ctes}${combined}${tail}`;
   }
 
-  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 {
+    if (ast.using) {
+      throw new Error('DELETE ... USING is not supported in the MSSQL dialect; use join() instead.');
+    }
+
     if (ast.from.type !== 'Table') {
       throw new Error('DELETE only supports base tables in the MSSQL dialect.');
     }
-    const table = this.quoteIdentifier(ast.from.name);
+
+    const alias = ast.from.alias ?? ast.from.name;
+    const target = this.compileTableReference(ast.from);
+    const joins = JoinCompiler.compileJoins(
+      ast.joins,
+      ctx,
+      this.compileFrom.bind(this),
+      this.compileExpression.bind(this)
+    );
     const whereClause = this.compileWhere(ast.where, ctx);
-    return `DELETE FROM ${table}${whereClause};`;
+    const returning = this.compileReturning(ast.returning, ctx);
+    return `DELETE ${this.quoteIdentifier(alias)} FROM ${target}${joins}${whereClause}${returning}`;
   }
 
-  private compileSelectCore(ast: SelectQueryNode, ctx: CompilerContext): string {
+  private compileSelectCoreForMssql(ast: SelectQueryNode, ctx: CompilerContext): string {
     const columns = ast.columns.map(c => {
       let expr = '';
       if (c.type === 'Function') {
@@ -126,10 +127,10 @@ export class SqlServerDialect extends Dialect {
     }).join(', ');
 
     const distinct = ast.distinct ? 'DISTINCT ' : '';
-    const from = this.compileTableSource(ast.from, ctx);
+    const from = this.compileTableSource(ast.from);
 
     const joins = ast.joins.map(j => {
-      const table = this.compileTableSource(j.table, ctx);
+      const table = this.compileTableSource(j.table);
       const cond = this.compileExpression(j.condition, ctx);
       return `${j.kind} JOIN ${table} ON ${cond}`;
     }).join(' ');
@@ -176,35 +177,6 @@ export class SqlServerDialect extends Dialect {
     return pagination;
   }
 
-  private renderOrderByNulls(order: OrderByNode): string | undefined {
-    return order.nulls ? ` NULLS ${order.nulls}` : '';
-  }
-
-  private renderOrderByCollation(order: OrderByNode): string | undefined {
-    return order.collation ? ` COLLATE ${order.collation}` : '';
-  }
-
-  private compileTableSource(table: TableSourceNode, ctx: CompilerContext): string {
-    if (table.type === 'FunctionTable') {
-      return FunctionTableFormatter.format(table, ctx, this as any);
-    }
-    if (table.type === 'DerivedTable') {
-      return this.compileDerivedTable(table, ctx);
-    }
-    const base = table.schema
-      ? `${this.quoteIdentifier(table.schema)}.${this.quoteIdentifier(table.name)}`
-      : this.quoteIdentifier(table.name);
-    return table.alias ? `${base} AS ${this.quoteIdentifier(table.alias)}` : base;
-  }
-
-  private compileDerivedTable(table: DerivedTableNode, ctx: CompilerContext): string {
-    const sub = this.compileSelectAst(this.normalizeSelectAst(table.query), ctx).trim().replace(/;$/, '');
-    const cols = table.columnAliases?.length
-      ? ` (${table.columnAliases.map(c => this.quoteIdentifier(c)).join(', ')})`
-      : '';
-    return `(${sub}) AS ${this.quoteIdentifier(table.alias)}${cols}`;
-  }
-
   private compileCtes(ast: SelectQueryNode, ctx: CompilerContext): string {
     if (!ast.ctes || ast.ctes.length === 0) return '';
     // MSSQL does not use RECURSIVE keyword, but supports recursion when CTE references itself.
@@ -217,8 +189,4 @@ export class SqlServerDialect extends Dialect {
     return `WITH ${defs} `;
   }
 
-  private wrapSetOperand(sql: string): string {
-    const trimmed = sql.trim().replace(/;$/, '');
-    return `(${trimmed})`;
-  }
 }

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

@@ -1,11 +1,12 @@
-import { CompilerContext } from '../abstract.js';
-import { JsonPathNode, ColumnNode } from '../../ast/expression.js';
-import { SqlDialectBase } from '../base/sql-dialect.js';
-import { SqliteFunctionStrategy } from './functions.js';
-
-/**
- * SQLite dialect implementation
- */
+import { CompilerContext } from '../abstract.js';
+import { JsonPathNode, ColumnNode } from '../../ast/expression.js';
+import { TableNode } from '../../ast/query.js';
+import { SqlDialectBase } from '../base/sql-dialect.js';
+import { SqliteFunctionStrategy } from './functions.js';
+
+/**
+ * SQLite dialect implementation
+ */
 export class SqliteDialect extends SqlDialectBase {
   protected readonly dialect = 'sqlite';
   /**
@@ -14,27 +15,31 @@ export class SqliteDialect extends SqlDialectBase {
   public constructor() {
     super(new SqliteFunctionStrategy());
   }
-
-  /**
-   * Quotes an identifier using SQLite double-quote syntax
-   * @param id - Identifier to quote
-   * @returns Quoted identifier
-   */
-  quoteIdentifier(id: string): string {
-    return `"${id}"`;
-  }
-
-  /**
-   * Compiles JSON path expression using SQLite syntax
-   * @param node - JSON path node
-   * @returns SQLite JSON path expression
-   */
-  protected compileJsonPath(node: JsonPathNode): string {
-    const col = `${this.quoteIdentifier(node.column.table)}.${this.quoteIdentifier(node.column.name)}`;
-    // SQLite uses json_extract(col, '$.path')
-    return `json_extract(${col}, '${node.path}')`;
-  }
-
+
+  /**
+   * Quotes an identifier using SQLite double-quote syntax
+   * @param id - Identifier to quote
+   * @returns Quoted identifier
+   */
+  quoteIdentifier(id: string): string {
+    return `"${id}"`;
+  }
+
+  /**
+   * Compiles JSON path expression using SQLite syntax
+   * @param node - JSON path node
+   * @returns SQLite JSON path expression
+   */
+  protected compileJsonPath(node: JsonPathNode): string {
+    const col = `${this.quoteIdentifier(node.column.table)}.${this.quoteIdentifier(node.column.name)}`;
+    // SQLite uses json_extract(col, '$.path')
+    return `json_extract(${col}, '${node.path}')`;
+  }
+
+  protected compileQualifiedColumn(column: ColumnNode, _table: TableNode): string {
+    return this.quoteIdentifier(column.name);
+  }
+
   protected compileReturning(returning: ColumnNode[] | undefined, ctx: CompilerContext): string {
     if (!returning || returning.length === 0) return '';
     const columns = this.formatReturningColumns(returning);
@@ -49,8 +54,8 @@ export class SqliteDialect extends SqlDialectBase {
       })
       .join(', ');
   }
-
-  supportsReturning(): boolean {
-    return true;
-  }
-}
+
+  supportsReturning(): boolean {
+    return true;
+  }
+}