metal-orm 1.1.10 → 1.1.16

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

@@ -5,55 +5,55 @@ import { SqlDialectBase } from '../base/sql-dialect.js';
 import { PostgresFunctionStrategy } from './functions.js';
 import { PostgresTableFunctionStrategy } from './table-functions.js';
 import { ProcedureCallNode } from '../../ast/procedure.js';
-
-/**
- * PostgreSQL dialect implementation
- */
-export class PostgresDialect extends SqlDialectBase {
-  protected readonly dialect = 'postgres';
-  /**
-   * Creates a new PostgresDialect instance
-   */
-  public constructor() {
-    super(new PostgresFunctionStrategy(), new PostgresTableFunctionStrategy());
-    this.registerExpressionCompiler('BitwiseExpression', (node: BitwiseExpressionNode, ctx) => {
-      const left = this.compileOperand(node.left, ctx);
-      const right = this.compileOperand(node.right, ctx);
-      const op = node.operator === '^' ? '#' : node.operator;
-      return `${left} ${op} ${right}`;
-    });
-    this.registerOperandCompiler('BitwiseExpression', (node: BitwiseExpressionNode, ctx) => {
-      const left = this.compileOperand(node.left, ctx);
-      const right = this.compileOperand(node.right, ctx);
-      const op = node.operator === '^' ? '#' : node.operator;
-      return `(${left} ${op} ${right})`;
-    });
-  }
-
-  /**
-   * Quotes an identifier using PostgreSQL double-quote syntax
-   * @param id - Identifier to quote
-   * @returns Quoted identifier
-   */
-  quoteIdentifier(id: string): string {
-    return `"${id}"`;
-  }
-
-  protected formatPlaceholder(index: number): string {
-    return `$${index}`;
-  }
-
-  /**
-   * Compiles JSON path expression using PostgreSQL syntax
-   * @param node - JSON path node
-   * @returns PostgreSQL JSON path expression
-   */
-  protected compileJsonPath(node: JsonPathNode): string {
-    const col = `${this.quoteIdentifier(node.column.table)}.${this.quoteIdentifier(node.column.name)}`;
-    // Postgres uses col->>'path' for text extraction
-    return `${col}->>'${node.path}'`;
-  }
-
+
+/**
+ * PostgreSQL dialect implementation
+ */
+export class PostgresDialect extends SqlDialectBase {
+  protected readonly dialect = 'postgres';
+  /**
+   * Creates a new PostgresDialect instance
+   */
+  public constructor() {
+    super(new PostgresFunctionStrategy(), new PostgresTableFunctionStrategy());
+    this.registerExpressionCompiler('BitwiseExpression', (node: BitwiseExpressionNode, ctx) => {
+      const left = this.compileOperand(node.left, ctx);
+      const right = this.compileOperand(node.right, ctx);
+      const op = node.operator === '^' ? '#' : node.operator;
+      return `${left} ${op} ${right}`;
+    });
+    this.registerOperandCompiler('BitwiseExpression', (node: BitwiseExpressionNode, ctx) => {
+      const left = this.compileOperand(node.left, ctx);
+      const right = this.compileOperand(node.right, ctx);
+      const op = node.operator === '^' ? '#' : node.operator;
+      return `(${left} ${op} ${right})`;
+    });
+  }
+
+  /**
+   * Quotes an identifier using PostgreSQL double-quote syntax
+   * @param id - Identifier to quote
+   * @returns Quoted identifier
+   */
+  quoteIdentifier(id: string): string {
+    return `"${id}"`;
+  }
+
+  protected formatPlaceholder(index: number): string {
+    return `$${index}`;
+  }
+
+  /**
+   * Compiles JSON path expression using PostgreSQL syntax
+   * @param node - JSON path node
+   * @returns PostgreSQL JSON path expression
+   */
+  protected compileJsonPath(node: JsonPathNode): string {
+    const col = `${this.quoteIdentifier(node.column.table)}.${this.quoteIdentifier(node.column.name)}`;
+    // Postgres uses col->>'path' for text extraction
+    return `${col}->>'${node.path}'`;
+  }
+
   protected compileReturning(returning: ColumnNode[] | undefined, ctx: CompilerContext): string {
     void ctx;
     if (!returning || returning.length === 0) return '';
@@ -90,45 +90,45 @@ export class PostgresDialect extends SqlDialectBase {
       : '';
     return `${target} DO UPDATE SET ${assignments}${where}`;
   }
-
-  supportsDmlReturningClause(): boolean {
-    return true;
-  }
-
-  compileProcedureCall(ast: ProcedureCallNode): CompiledProcedureCall {
-    const ctx = this.createCompilerContext();
-    const qualifiedName = ast.ref.schema
-      ? `${this.quoteIdentifier(ast.ref.schema)}.${this.quoteIdentifier(ast.ref.name)}`
-      : this.quoteIdentifier(ast.ref.name);
-
-    const args: string[] = [];
-    for (const param of ast.params) {
-      if (param.direction === 'out') continue;
-      if (!param.value) {
-        throw new Error(`Procedure parameter "${param.name}" requires a value for direction "${param.direction}".`);
-      }
-      args.push(this.compileOperand(param.value, ctx));
-    }
-
-    const outNames = ast.params
-      .filter(param => param.direction === 'out' || param.direction === 'inout')
-      .map(param => param.name);
-
-    const rawSql = `CALL ${qualifiedName}(${args.join(', ')})`;
-    return {
-      sql: `${rawSql};`,
-      params: [...ctx.params],
-      outParams: {
-        source: outNames.length ? 'firstResultSet' : 'none',
-        names: outNames
-      }
-    };
-  }
-
-  /**
-   * PostgreSQL requires unqualified column names in SET clause
-   */
-  protected compileSetTarget(column: ColumnNode, _table: TableNode): string {
-    return this.quoteIdentifier(column.name);
-  }
-}
+
+  supportsDmlReturningClause(): boolean {
+    return true;
+  }
+
+  compileProcedureCall(ast: ProcedureCallNode): CompiledProcedureCall {
+    const ctx = this.createCompilerContext();
+    const qualifiedName = ast.ref.schema
+      ? `${this.quoteIdentifier(ast.ref.schema)}.${this.quoteIdentifier(ast.ref.name)}`
+      : this.quoteIdentifier(ast.ref.name);
+
+    const args: string[] = [];
+    for (const param of ast.params) {
+      if (param.direction === 'out') continue;
+      if (!param.value) {
+        throw new Error(`Procedure parameter "${param.name}" requires a value for direction "${param.direction}".`);
+      }
+      args.push(this.compileOperand(param.value, ctx));
+    }
+
+    const outNames = ast.params
+      .filter(param => param.direction === 'out' || param.direction === 'inout')
+      .map(param => param.name);
+
+    const rawSql = `CALL ${qualifiedName}(${args.join(', ')})`;
+    return {
+      sql: `${rawSql};`,
+      params: [...ctx.params],
+      outParams: {
+        source: outNames.length ? 'firstResultSet' : 'none',
+        names: outNames
+      }
+    };
+  }
+
+  /**
+   * PostgreSQL requires unqualified column names in SET clause
+   */
+  protected compileSetTarget(column: ColumnNode, _table: TableNode): string {
+    return this.quoteIdentifier(column.name);
+  }
+}

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

@@ -1,130 +1,130 @@
-import { StandardFunctionStrategy } from '../../functions/standard-strategy.js';
-import { LiteralNode } from '../../ast/expression.js';
-
-/**
- * SQLite specific function strategy.
- * Implements and overrides SQL function compilation rules for SQLite.
- */
-export class SqliteFunctionStrategy extends StandardFunctionStrategy {
-    constructor() {
-        super();
-        this.registerOverrides();
-    }
-
-    private registerOverrides() {
-        // Override Standard/Abstract definitions with SQLite specifics
-
-        // Date/Time functions
-        this.add('NOW', () => `datetime('now', 'localtime')`);
-        this.add('CURRENT_DATE', () => `date('now', 'localtime')`);
-        this.add('CURRENT_TIME', () => `time('now', 'localtime')`);
-        this.add('UTC_NOW', () => `datetime('now')`);
-
-        this.add('EXTRACT', ({ compiledArgs }) => {
-            if (compiledArgs.length !== 2) throw new Error('EXTRACT expects 2 arguments (part, date)');
-            const [part, date] = compiledArgs;
-            // Map common parts to strftime format
-            const partUpper = part.replace(/['"]/g, '').toUpperCase();
-            const formatMap: Record<string, string> = {
-                'YEAR': '%Y', 'MONTH': '%m', 'DAY': '%d',
-                'HOUR': '%H', 'MINUTE': '%M', 'SECOND': '%S',
-                'DOW': '%w', 'WEEK': '%W'
-            };
-            const format = formatMap[partUpper] || '%Y';
-            return `CAST(strftime('${format}', ${date}) AS INTEGER)`;
-        });
-
-        this.add('YEAR', ({ compiledArgs }) => {
-            if (compiledArgs.length !== 1) throw new Error('YEAR expects 1 argument');
-            return `CAST(strftime('%Y', ${compiledArgs[0]}) AS INTEGER)`;
-        });
-
-        this.add('MONTH', ({ compiledArgs }) => {
-            if (compiledArgs.length !== 1) throw new Error('MONTH expects 1 argument');
-            return `CAST(strftime('%m', ${compiledArgs[0]}) AS INTEGER)`;
-        });
-
-        this.add('DAY', ({ compiledArgs }) => {
-            if (compiledArgs.length !== 1) throw new Error('DAY expects 1 argument');
-            return `CAST(strftime('%d', ${compiledArgs[0]}) AS INTEGER)`;
-        });
-
-        this.add('DATE_ADD', ({ node, compiledArgs }) => {
-            if (compiledArgs.length !== 3) throw new Error('DATE_ADD expects 3 arguments (date, interval, unit)');
-            const [date, interval] = compiledArgs;
-            const unitArg = node.args[2] as LiteralNode;
-            const unitClean = String(unitArg.value).replace(/['"]/g, '').toLowerCase();
-            return `datetime(${date}, '+' || ${interval} || ' ${unitClean}')`;
-        });
-
-        this.add('DATE_SUB', ({ node, compiledArgs }) => {
-            if (compiledArgs.length !== 3) throw new Error('DATE_SUB expects 3 arguments (date, interval, unit)');
-            const [date, interval] = compiledArgs;
-            const unitArg = node.args[2] as LiteralNode;
-            const unitClean = String(unitArg.value).replace(/['"]/g, '').toLowerCase();
-            return `datetime(${date}, '-' || ${interval} || ' ${unitClean}')`;
-        });
-
-        this.add('DATE_DIFF', ({ compiledArgs }) => {
-            if (compiledArgs.length !== 2) throw new Error('DATE_DIFF expects 2 arguments');
-            const [date1, date2] = compiledArgs;
-            return `CAST(julianday(${date1}) - julianday(${date2}) AS INTEGER)`;
-        });
-
-        this.add('DATE_FORMAT', ({ compiledArgs }) => {
-            if (compiledArgs.length !== 2) throw new Error('DATE_FORMAT expects 2 arguments');
-            const [date, format] = compiledArgs;
-            return `strftime(${format}, ${date})`;
-        });
-
-        this.add('UNIX_TIMESTAMP', () => `CAST(strftime('%s', 'now') AS INTEGER)`);
-
-        this.add('FROM_UNIXTIME', ({ compiledArgs }) => {
-            if (compiledArgs.length !== 1) throw new Error('FROM_UNIXTIME expects 1 argument');
-            return `datetime(${compiledArgs[0]}, 'unixepoch')`;
-        });
-
-        this.add('END_OF_MONTH', ({ compiledArgs }) => {
-            if (compiledArgs.length !== 1) throw new Error('END_OF_MONTH expects 1 argument');
-            return `date(${compiledArgs[0]}, 'start of month', '+1 month', '-1 day')`;
-        });
-
-        this.add('DAY_OF_WEEK', ({ compiledArgs }) => {
-            if (compiledArgs.length !== 1) throw new Error('DAY_OF_WEEK expects 1 argument');
-            return `CAST(strftime('%w', ${compiledArgs[0]}) AS INTEGER)`;
-        });
-
-        this.add('WEEK_OF_YEAR', ({ compiledArgs }) => {
-            if (compiledArgs.length !== 1) throw new Error('WEEK_OF_YEAR expects 1 argument');
-            return `CAST(strftime('%W', ${compiledArgs[0]}) AS INTEGER)`;
-        });
-
-        this.add('DATE_TRUNC', ({ node, compiledArgs }) => {
-            if (compiledArgs.length !== 2) throw new Error('DATE_TRUNC expects 2 arguments (part, date)');
-            const [, date] = compiledArgs;
-            const partArg = node.args[0] as LiteralNode;
-            const partClean = String(partArg.value).replace(/['"]/g, '').toLowerCase();
-            // SQLite uses date modifiers
-            if (partClean === 'year') {
-                return `date(${date}, 'start of year')`;
-            } else if (partClean === 'month') {
-                return `date(${date}, 'start of month')`;
-            } else if (partClean === 'day') {
-                return `date(${date})`;
-            }
-            return `date(${date}, 'start of ${partClean}')`;
-        });
-
-        this.add('GROUP_CONCAT', ctx => {
-            const arg = ctx.compiledArgs[0];
-            const separatorOperand = this.getGroupConcatSeparatorOperand(ctx);
-            const separator = ctx.compileOperand(separatorOperand);
-            return `GROUP_CONCAT(${arg}, ${separator})`;
-        });
-
-        this.add('HOUR', ({ compiledArgs }) => `CAST(strftime('%H', ${compiledArgs[0]}) AS INTEGER)`);
-        this.add('MINUTE', ({ compiledArgs }) => `CAST(strftime('%M', ${compiledArgs[0]}) AS INTEGER)`);
-        this.add('SECOND', ({ compiledArgs }) => `CAST(strftime('%S', ${compiledArgs[0]}) AS INTEGER)`);
+import { StandardFunctionStrategy } from '../../functions/standard-strategy.js';
+import { LiteralNode } from '../../ast/expression.js';
+
+/**
+ * SQLite specific function strategy.
+ * Implements and overrides SQL function compilation rules for SQLite.
+ */
+export class SqliteFunctionStrategy extends StandardFunctionStrategy {
+    constructor() {
+        super();
+        this.registerOverrides();
+    }
+
+    private registerOverrides() {
+        // Override Standard/Abstract definitions with SQLite specifics
+
+        // Date/Time functions
+        this.add('NOW', () => `datetime('now', 'localtime')`);
+        this.add('CURRENT_DATE', () => `date('now', 'localtime')`);
+        this.add('CURRENT_TIME', () => `time('now', 'localtime')`);
+        this.add('UTC_NOW', () => `datetime('now')`);
+
+        this.add('EXTRACT', ({ compiledArgs }) => {
+            if (compiledArgs.length !== 2) throw new Error('EXTRACT expects 2 arguments (part, date)');
+            const [part, date] = compiledArgs;
+            // Map common parts to strftime format
+            const partUpper = part.replace(/['"]/g, '').toUpperCase();
+            const formatMap: Record<string, string> = {
+                'YEAR': '%Y', 'MONTH': '%m', 'DAY': '%d',
+                'HOUR': '%H', 'MINUTE': '%M', 'SECOND': '%S',
+                'DOW': '%w', 'WEEK': '%W'
+            };
+            const format = formatMap[partUpper] || '%Y';
+            return `CAST(strftime('${format}', ${date}) AS INTEGER)`;
+        });
+
+        this.add('YEAR', ({ compiledArgs }) => {
+            if (compiledArgs.length !== 1) throw new Error('YEAR expects 1 argument');
+            return `CAST(strftime('%Y', ${compiledArgs[0]}) AS INTEGER)`;
+        });
+
+        this.add('MONTH', ({ compiledArgs }) => {
+            if (compiledArgs.length !== 1) throw new Error('MONTH expects 1 argument');
+            return `CAST(strftime('%m', ${compiledArgs[0]}) AS INTEGER)`;
+        });
+
+        this.add('DAY', ({ compiledArgs }) => {
+            if (compiledArgs.length !== 1) throw new Error('DAY expects 1 argument');
+            return `CAST(strftime('%d', ${compiledArgs[0]}) AS INTEGER)`;
+        });
+
+        this.add('DATE_ADD', ({ node, compiledArgs }) => {
+            if (compiledArgs.length !== 3) throw new Error('DATE_ADD expects 3 arguments (date, interval, unit)');
+            const [date, interval] = compiledArgs;
+            const unitArg = node.args[2] as LiteralNode;
+            const unitClean = String(unitArg.value).replace(/['"]/g, '').toLowerCase();
+            return `datetime(${date}, '+' || ${interval} || ' ${unitClean}')`;
+        });
+
+        this.add('DATE_SUB', ({ node, compiledArgs }) => {
+            if (compiledArgs.length !== 3) throw new Error('DATE_SUB expects 3 arguments (date, interval, unit)');
+            const [date, interval] = compiledArgs;
+            const unitArg = node.args[2] as LiteralNode;
+            const unitClean = String(unitArg.value).replace(/['"]/g, '').toLowerCase();
+            return `datetime(${date}, '-' || ${interval} || ' ${unitClean}')`;
+        });
+
+        this.add('DATE_DIFF', ({ compiledArgs }) => {
+            if (compiledArgs.length !== 2) throw new Error('DATE_DIFF expects 2 arguments');
+            const [date1, date2] = compiledArgs;
+            return `CAST(julianday(${date1}) - julianday(${date2}) AS INTEGER)`;
+        });
+
+        this.add('DATE_FORMAT', ({ compiledArgs }) => {
+            if (compiledArgs.length !== 2) throw new Error('DATE_FORMAT expects 2 arguments');
+            const [date, format] = compiledArgs;
+            return `strftime(${format}, ${date})`;
+        });
+
+        this.add('UNIX_TIMESTAMP', () => `CAST(strftime('%s', 'now') AS INTEGER)`);
+
+        this.add('FROM_UNIXTIME', ({ compiledArgs }) => {
+            if (compiledArgs.length !== 1) throw new Error('FROM_UNIXTIME expects 1 argument');
+            return `datetime(${compiledArgs[0]}, 'unixepoch')`;
+        });
+
+        this.add('END_OF_MONTH', ({ compiledArgs }) => {
+            if (compiledArgs.length !== 1) throw new Error('END_OF_MONTH expects 1 argument');
+            return `date(${compiledArgs[0]}, 'start of month', '+1 month', '-1 day')`;
+        });
+
+        this.add('DAY_OF_WEEK', ({ compiledArgs }) => {
+            if (compiledArgs.length !== 1) throw new Error('DAY_OF_WEEK expects 1 argument');
+            return `CAST(strftime('%w', ${compiledArgs[0]}) AS INTEGER)`;
+        });
+
+        this.add('WEEK_OF_YEAR', ({ compiledArgs }) => {
+            if (compiledArgs.length !== 1) throw new Error('WEEK_OF_YEAR expects 1 argument');
+            return `CAST(strftime('%W', ${compiledArgs[0]}) AS INTEGER)`;
+        });
+
+        this.add('DATE_TRUNC', ({ node, compiledArgs }) => {
+            if (compiledArgs.length !== 2) throw new Error('DATE_TRUNC expects 2 arguments (part, date)');
+            const [, date] = compiledArgs;
+            const partArg = node.args[0] as LiteralNode;
+            const partClean = String(partArg.value).replace(/['"]/g, '').toLowerCase();
+            // SQLite uses date modifiers
+            if (partClean === 'year') {
+                return `date(${date}, 'start of year')`;
+            } else if (partClean === 'month') {
+                return `date(${date}, 'start of month')`;
+            } else if (partClean === 'day') {
+                return `date(${date})`;
+            }
+            return `date(${date}, 'start of ${partClean}')`;
+        });
+
+        this.add('GROUP_CONCAT', ctx => {
+            const arg = ctx.compiledArgs[0];
+            const separatorOperand = this.getGroupConcatSeparatorOperand(ctx);
+            const separator = ctx.compileOperand(separatorOperand);
+            return `GROUP_CONCAT(${arg}, ${separator})`;
+        });
+
+        this.add('HOUR', ({ compiledArgs }) => `CAST(strftime('%H', ${compiledArgs[0]}) AS INTEGER)`);
+        this.add('MINUTE', ({ compiledArgs }) => `CAST(strftime('%M', ${compiledArgs[0]}) AS INTEGER)`);
+        this.add('SECOND', ({ compiledArgs }) => `CAST(strftime('%S', ${compiledArgs[0]}) AS INTEGER)`);
         this.add('QUARTER', ({ compiledArgs }) => `((CAST(strftime('%m', ${compiledArgs[0]}) AS INTEGER) + 2) / 3)`);
 
         this.add('JSON_LENGTH', ({ compiledArgs }) => {
@@ -151,5 +151,5 @@ export class SqliteFunctionStrategy extends StandardFunctionStrategy {
         });
 
         this.add('CHR', ({ compiledArgs }) => `CHAR(${compiledArgs[0]})`);
-    }
-}
+    }
+}

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

@@ -4,67 +4,67 @@ import { InsertQueryNode, TableNode } from '../../ast/query.js';
 import { SqlDialectBase } from '../base/sql-dialect.js';
 import { SqliteFunctionStrategy } from './functions.js';
 import { ProcedureCallNode } from '../../ast/procedure.js';
-
-/**
- * SQLite dialect implementation
- */
-export class SqliteDialect extends SqlDialectBase {
-  protected readonly dialect = 'sqlite';
-  /**
-   * Creates a new SqliteDialect instance
-   */
-  public constructor() {
-    super(new SqliteFunctionStrategy());
-    this.registerExpressionCompiler('BitwiseExpression', (node: BitwiseExpressionNode, ctx) => {
-      const left = this.compileOperand(node.left, ctx);
-      const right = this.compileOperand(node.right, ctx);
-      if (node.operator === '^') {
-        return `(${left} | ${right}) & ~(${left} & ${right})`;
-      }
-      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);
-      if (node.operator === '^') {
-        return `((${left} | ${right}) & ~(${left} & ${right}))`;
-      }
-      return `(${left} ${node.operator} ${right})`;
-    });
-  }
-
-  /**
-   * 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 {
-    void _table;
-    return this.quoteIdentifier(column.name);
-  }
-
-  protected compileReturning(returning: ColumnNode[] | undefined, ctx: CompilerContext): string {
-    void ctx;
-    if (!returning || returning.length === 0) return '';
-    const columns = this.formatReturningColumns(returning);
-    return ` RETURNING ${columns}`;
-  }
-
+
+/**
+ * SQLite dialect implementation
+ */
+export class SqliteDialect extends SqlDialectBase {
+  protected readonly dialect = 'sqlite';
+  /**
+   * Creates a new SqliteDialect instance
+   */
+  public constructor() {
+    super(new SqliteFunctionStrategy());
+    this.registerExpressionCompiler('BitwiseExpression', (node: BitwiseExpressionNode, ctx) => {
+      const left = this.compileOperand(node.left, ctx);
+      const right = this.compileOperand(node.right, ctx);
+      if (node.operator === '^') {
+        return `(${left} | ${right}) & ~(${left} & ${right})`;
+      }
+      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);
+      if (node.operator === '^') {
+        return `((${left} | ${right}) & ~(${left} & ${right}))`;
+      }
+      return `(${left} ${node.operator} ${right})`;
+    });
+  }
+
+  /**
+   * 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 {
+    void _table;
+    return this.quoteIdentifier(column.name);
+  }
+
+  protected compileReturning(returning: ColumnNode[] | undefined, ctx: CompilerContext): string {
+    void ctx;
+    if (!returning || returning.length === 0) return '';
+    const columns = this.formatReturningColumns(returning);
+    return ` RETURNING ${columns}`;
+  }
+
   protected formatReturningColumns(returning: ColumnNode[]): string {
     return returning
       .map(column => {
@@ -104,9 +104,9 @@ export class SqliteDialect extends SqlDialectBase {
   supportsDmlReturningClause(): boolean {
     return true;
   }
-
-  compileProcedureCall(_ast: ProcedureCallNode): CompiledProcedureCall {
-    void _ast;
-    throw new Error('Stored procedures are not supported by the SQLite dialect.');
-  }
-}
+
+  compileProcedureCall(_ast: ProcedureCallNode): CompiledProcedureCall {
+    void _ast;
+    throw new Error('Stored procedures are not supported by the SQLite dialect.');
+  }
+}

package/src/core/driver/database-driver.ts

@@ -1,19 +1,19 @@
-import type { Dialect } from '../dialect/abstract.js';
-import type { SchemaDialect } from '../ddl/schema-dialect.js';
-import type { SchemaIntrospector } from '../ddl/schema-introspect.js';
-
-/**
- * Interface for database drivers.
- * A driver provides access to dialect-specific compilers and introspectors.
- */
-export interface DatabaseDriver {
-  /** The name of the driver (e.g., "postgres", "mysql"). */
-  readonly name: string;
-
-  /** Creates a query compiler dialect. */
-  createDialect(): Dialect;
-  /** Creates a DDL/schema dialect. */
-  createSchemaDialect(): SchemaDialect;
-  /** Creates a schema introspector. */
-  createIntrospector(): SchemaIntrospector;
-}
+import type { Dialect } from '../dialect/abstract.js';
+import type { SchemaDialect } from '../ddl/schema-dialect.js';
+import type { SchemaIntrospector } from '../ddl/schema-introspect.js';
+
+/**
+ * Interface for database drivers.
+ * A driver provides access to dialect-specific compilers and introspectors.
+ */
+export interface DatabaseDriver {
+  /** The name of the driver (e.g., "postgres", "mysql"). */
+  readonly name: string;
+
+  /** Creates a query compiler dialect. */
+  createDialect(): Dialect;
+  /** Creates a DDL/schema dialect. */
+  createSchemaDialect(): SchemaDialect;
+  /** Creates a schema introspector. */
+  createIntrospector(): SchemaIntrospector;
+}