metal-orm 1.1.9 → 1.1.11

package/src/bulk/bulk-executor.base.ts

@@ -0,0 +1,73 @@
+import type { TableDef } from '../schema/table.js';
+import type { OrmSession } from '../orm/orm-session.js';
+import type { BulkResult, BulkBaseOptions, ChunkOutcome } from './bulk-types.js';
+import { createBulkExecutionContext, type BulkExecutionContext } from './bulk-context.js';
+import {
+  splitIntoChunks,
+  runWithConcurrency,
+  runChunk,
+  maybeTransaction,
+  aggregateOutcomes,
+  aggregateOutcomesWithTimings,
+} from './bulk-utils.js';
+
+const DEFAULT_CHUNK_SIZE = 500;
+
+export interface BulkExecutorOptions extends BulkBaseOptions {
+  chunkSize?: number;
+  concurrency?: 'sequential' | number;
+  transactional?: boolean;
+  timing?: boolean;
+  onChunkComplete?: (info: { chunkIndex: number; totalChunks: number; rowsInChunk: number; elapsedMs: number }) => void | Promise<void>;
+}
+
+export abstract class BulkBaseExecutor<TOptions extends BulkExecutorOptions> {
+  protected readonly session: OrmSession;
+  protected readonly table: TableDef;
+  protected readonly ctx: BulkExecutionContext;
+  protected readonly options: TOptions;
+  protected readonly chunks: unknown[][];
+  protected readonly totalChunks: number;
+
+  constructor(session: OrmSession, table: TableDef, rows: unknown[], options: TOptions = {} as TOptions) {
+    this.session = session;
+    this.table = table;
+    this.ctx = createBulkExecutionContext(session);
+    this.options = {
+      chunkSize: DEFAULT_CHUNK_SIZE,
+      concurrency: 'sequential',
+      transactional: true,
+      timing: false,
+      ...options,
+    } as TOptions;
+    this.chunks = splitIntoChunks(rows, this.options.chunkSize!);
+    this.totalChunks = this.chunks.length;
+  }
+
+  protected abstract executeChunk(chunk: unknown[], chunkIndex: number): Promise<ChunkOutcome>;
+
+  async execute(): Promise<BulkResult> {
+    const buildTask = (chunk: unknown[], chunkIndex: number) => async (): Promise<ChunkOutcome> => {
+      return runChunk(
+        () => this.executeChunk(chunk, chunkIndex),
+        chunkIndex,
+        this.totalChunks,
+        chunk.length,
+        this.options.timing!,
+        this.options.onChunkComplete
+      );
+    };
+
+    const tasks = this.chunks.map((chunk, i) => buildTask(chunk, i));
+
+    const outcomes = await maybeTransaction(
+      this.session,
+      this.options.transactional!,
+      () => runWithConcurrency(tasks, this.options.concurrency!)
+    );
+
+    return this.options.timing
+      ? aggregateOutcomesWithTimings(outcomes)
+      : aggregateOutcomes(outcomes);
+  }
+}

package/src/bulk/bulk-insert-executor.ts

@@ -0,0 +1,74 @@
+import { InsertQueryBuilder, ConflictBuilder } from '../query-builder/insert.js';
+import type { TableDef } from '../schema/table.js';
+import type { OrmSession } from '../orm/orm-session.js';
+import type { BulkInsertOptions, ChunkOutcome, InsertRow } from './bulk-types.js';
+import { BulkBaseExecutor, type BulkExecutorOptions } from './bulk-executor.base.js';
+import { resolveReturningColumns, flattenQueryResults, executeCompiled } from './bulk-context.js';
+import type { ValueOperandInput } from '../core/ast/expression.js';
+
+interface InsertExecutorOptions extends BulkExecutorOptions {
+  returning?: boolean | import('../schema/column-types.js').ColumnDef[];
+  onConflict?: import('../core/ast/query.js').UpsertClause;
+}
+
+export class BulkInsertExecutor extends BulkBaseExecutor<InsertExecutorOptions> {
+  constructor(
+    session: OrmSession,
+    table: TableDef,
+    rows: InsertRow[],
+    options: BulkInsertOptions = {}
+  ) {
+    super(session, table, rows, options);
+  }
+
+  protected async executeChunk(chunk: InsertRow[], _chunkIndex: number): Promise<ChunkOutcome> {
+    const returningColumns = resolveReturningColumns(this.ctx, this.table, this.options.returning);
+
+    let builder: InsertQueryBuilder<unknown> | ConflictBuilder<unknown> = new InsertQueryBuilder(this.table).values(chunk);
+
+    if (this.options.onConflict) {
+      const conflictColumns = this.options.onConflict.target?.columns ?? [];
+      const conflictBuilder = (builder as InsertQueryBuilder<unknown>).onConflict(conflictColumns);
+      
+      if (this.options.onConflict.action.type === 'DoNothing') {
+        builder = conflictBuilder.doNothing();
+      } else if (this.options.onConflict.action.type === 'DoUpdate' && this.options.onConflict.action.set) {
+        const setMap: Record<string, ValueOperandInput> = {};
+        for (const assignment of this.options.onConflict.action.set) {
+          const colName = typeof assignment.column === 'object' ? assignment.column.name : assignment.column;
+          setMap[colName] = assignment.value;
+        }
+        builder = conflictBuilder.doUpdate(setMap);
+      }
+    }
+
+    const finalBuilder = builder as InsertQueryBuilder<unknown>;
+
+    if (returningColumns?.length) {
+      finalBuilder.returning(...returningColumns);
+    }
+
+    const compiled = finalBuilder.compile(this.ctx.dialect);
+    const resultSets = await executeCompiled(this.ctx, compiled);
+
+    return {
+      processedRows: chunk.length,
+      returning: returningColumns ? flattenQueryResults(resultSets) : [],
+      elapsedMs: 0,
+    };
+  }
+}
+
+export async function bulkInsert<TTable extends TableDef>(
+  session: OrmSession,
+  table: TTable,
+  rows: InsertRow[],
+  options: BulkInsertOptions = {}
+): Promise<import('./bulk-types.js').BulkResult> {
+  if (!rows.length) {
+    return { processedRows: 0, chunksExecuted: 0, returning: [] };
+  }
+
+  const executor = new BulkInsertExecutor(session, table, rows, options);
+  return executor.execute();
+}

package/src/bulk/bulk-types.ts

@@ -0,0 +1,70 @@
+import type { TableDef } from '../schema/table.js';
+import type { OrmSession } from '../orm/orm-session.js';
+import type { ExpressionNode } from '../core/ast/expression-nodes.js';
+import type { ColumnDef } from '../schema/column-types.js';
+import type { UpsertClause } from '../core/ast/query.js';
+import type { ValueOperandInput } from '../core/ast/expression.js';
+
+export type { TableDef, OrmSession };
+
+export type BulkConcurrency = 'sequential' | number;
+
+export interface BulkResult {
+  processedRows: number;
+  chunksExecuted: number;
+  returning: Record<string, unknown>[];
+  chunkTimings?: number[];
+  metadata?: BulkResultMetadata;
+}
+
+export interface BulkResultMetadata {
+  strategy: 'individual' | 'batch' | 'whereIn';
+  dialect: string;
+  hasReturningSupport: boolean;
+}
+
+export interface BulkBaseOptions {
+  chunkSize?: number;
+  concurrency?: BulkConcurrency;
+  transactional?: boolean;
+  timing?: boolean;
+  onChunkComplete?: (info: ChunkCompleteInfo) => void | Promise<void>;
+}
+
+export interface ChunkCompleteInfo {
+  chunkIndex: number;
+  totalChunks: number;
+  rowsInChunk: number;
+  elapsedMs: number;
+}
+
+export type InsertRow = Record<string, ValueOperandInput>;
+
+export interface BulkInsertOptions extends BulkBaseOptions {
+  returning?: boolean | ColumnDef[];
+  onConflict?: UpsertClause;
+}
+
+export interface BulkUpsertOptions extends BulkInsertOptions {
+  conflictColumns?: string[];
+  updateColumns?: string[];
+}
+
+export type UpdateRow = Record<string, ValueOperandInput>;
+
+export interface BulkUpdateOptions extends BulkBaseOptions {
+  by?: string | string[];
+  where?: ExpressionNode;
+  returning?: boolean | ColumnDef[];
+}
+
+export interface BulkDeleteOptions extends BulkBaseOptions {
+  by?: string;
+  where?: ExpressionNode;
+}
+
+export interface ChunkOutcome {
+  processedRows: number;
+  returning: Record<string, unknown>[];
+  elapsedMs: number;
+}

package/src/bulk/bulk-update-executor.ts

@@ -0,0 +1,192 @@
+import { UpdateQueryBuilder } from '../query-builder/update.js';
+import { findPrimaryKey } from '../query-builder/hydration-planner.js';
+import { eq, and, inList } from '../core/ast/expression-builders.js';
+import type { TableDef } from '../schema/table.js';
+import type { OrmSession } from '../orm/orm-session.js';
+import type { BulkUpdateOptions, ChunkOutcome, UpdateRow } from './bulk-types.js';
+import type { ValueOperandInput } from '../core/ast/expression.js';
+import type { ExpressionNode } from '../core/ast/expression-nodes.js';
+import { BulkBaseExecutor, type BulkExecutorOptions } from './bulk-executor.base.js';
+import { resolveReturningColumns, flattenQueryResults, executeCompiled, createBulkExecutionContext } from './bulk-context.js';
+import { splitIntoChunks, runWithConcurrency, runChunk, maybeTransaction, aggregateOutcomes, aggregateOutcomesWithTimings } from './bulk-utils.js';
+
+interface UpdateExecutorOptions extends BulkExecutorOptions {
+  by?: string | string[];
+  where?: ExpressionNode;
+  returning?: boolean | import('../schema/column-types.js').ColumnDef[];
+}
+
+function resolveByColumns(table: TableDef, by: string | string[] | undefined): string[] {
+  if (!by) return [findPrimaryKey(table)];
+  return Array.isArray(by) ? by : [by];
+}
+
+export class BulkUpdateExecutor extends BulkBaseExecutor<UpdateExecutorOptions> {
+  private readonly byColumns: string[];
+
+  constructor(
+    session: OrmSession,
+    table: TableDef,
+    rows: UpdateRow[],
+    options: BulkUpdateOptions = {}
+  ) {
+    super(session, table, rows, options);
+    this.byColumns = resolveByColumns(table, options.by);
+  }
+
+  protected async executeChunk(chunk: UpdateRow[], _chunkIndex: number): Promise<ChunkOutcome> {
+    const allReturning: Record<string, unknown>[] = [];
+    const returningColumns = resolveReturningColumns(this.ctx, this.table, this.options.returning);
+    const extraWhere = this.options.where;
+
+    for (const row of chunk) {
+      const predicates = this.byColumns.map(colName => {
+        const col = this.table.columns[colName];
+        if (!col) {
+          throw new Error(
+            `bulkUpdate: column "${colName}" not found in table "${this.table.name}"`
+          );
+        }
+        const val = row[colName];
+        if (val === undefined) {
+          throw new Error(
+            `bulkUpdate: row is missing the identity column "${colName}" required by the "by" option`
+          );
+        }
+        return eq(col, val as ValueOperandInput);
+      });
+
+      const whereExpr: ExpressionNode =
+        predicates.length === 1
+          ? predicates[0]
+          : predicates.reduce((acc, p) => and(acc, p) as ExpressionNode, predicates[0]);
+
+      const finalWhere = extraWhere ? and(whereExpr, extraWhere) as ExpressionNode : whereExpr;
+
+      const bySet = new Set(this.byColumns);
+      const setPayload: Record<string, unknown> = {};
+      for (const [key, val] of Object.entries(row)) {
+        if (!bySet.has(key) && key in this.table.columns) {
+          setPayload[key] = val;
+        }
+      }
+
+      if (!Object.keys(setPayload).length) continue;
+
+      let builder = new UpdateQueryBuilder(this.table).set(setPayload).where(finalWhere);
+
+      if (returningColumns?.length) {
+        builder = builder.returning(...returningColumns);
+      }
+
+      const compiled = builder.compile(this.ctx.dialect);
+      const resultSets = await executeCompiled(this.ctx, compiled);
+
+      if (returningColumns) {
+        allReturning.push(...flattenQueryResults(resultSets));
+      }
+    }
+
+    return {
+      processedRows: chunk.length,
+      returning: allReturning,
+      elapsedMs: 0,
+    };
+  }
+}
+
+export async function bulkUpdate<TTable extends TableDef>(
+  session: OrmSession,
+  table: TTable,
+  rows: UpdateRow[],
+  options: BulkUpdateOptions = {}
+): Promise<import('./bulk-types.js').BulkResult> {
+  if (!rows.length) {
+    return { processedRows: 0, chunksExecuted: 0, returning: [] };
+  }
+
+  const executor = new BulkUpdateExecutor(session, table, rows, options);
+  return executor.execute();
+}
+
+const DEFAULT_BULK_UPDATE_WHERE_CHUNK_SIZE = 500;
+
+export async function bulkUpdateWhere<TTable extends TableDef>(
+  session: OrmSession,
+  table: TTable,
+  ids: ValueOperandInput[],
+  set: Record<string, ValueOperandInput>,
+  options: Omit<BulkUpdateOptions, 'by' | 'returning'> & {
+    by?: string;
+    returning?: boolean | import('../schema/column-types.js').ColumnDef[];
+  } = {}
+): Promise<import('./bulk-types.js').BulkResult> {
+  if (!ids.length) {
+    return { processedRows: 0, chunksExecuted: 0, returning: [] };
+  }
+
+  const {
+    chunkSize = DEFAULT_BULK_UPDATE_WHERE_CHUNK_SIZE,
+    concurrency = 'sequential',
+    transactional = true,
+    timing = false,
+    onChunkComplete,
+    by,
+    where: extraWhere,
+    returning,
+  } = options;
+
+  const ctx = createBulkExecutionContext(session);
+  const byColumnName = by ?? findPrimaryKey(table);
+  const byColumn = table.columns[byColumnName];
+  if (!byColumn) {
+    throw new Error(
+      `bulkUpdateWhere: column "${byColumnName}" not found in table "${table.name}"`
+    );
+  }
+
+  const returningColumns = resolveReturningColumns(ctx, table, returning);
+  const chunks = splitIntoChunks(ids, chunkSize);
+  const totalChunks = chunks.length;
+
+  const buildTask = (chunk: ValueOperandInput[], chunkIndex: number) => async (): Promise<ChunkOutcome> => {
+    return runChunk(
+      async () => {
+        const inExpr = inList(byColumn, chunk as unknown as Parameters<typeof inList>[1]);
+        const finalWhere = extraWhere ? and(inExpr, extraWhere) : inExpr;
+
+        let builder = new UpdateQueryBuilder(table).set(set as Record<string, unknown>).where(finalWhere);
+
+        if (returningColumns?.length) {
+          builder = builder.returning(...returningColumns);
+        }
+
+        const compiled = builder.compile(ctx.dialect);
+        const resultSets = await executeCompiled(ctx, compiled);
+
+        return {
+          processedRows: chunk.length,
+          returning: returningColumns ? flattenQueryResults(resultSets) : [],
+          elapsedMs: 0,
+        };
+      },
+      chunkIndex,
+      totalChunks,
+      chunk.length,
+      timing,
+      onChunkComplete
+    );
+  };
+
+  const tasks = chunks.map((chunk, i) => buildTask(chunk, i));
+
+  const outcomes = await maybeTransaction(
+    session,
+    transactional,
+    () => runWithConcurrency(tasks, concurrency)
+  );
+
+  return timing
+    ? aggregateOutcomesWithTimings(outcomes)
+    : aggregateOutcomes(outcomes);
+}

package/src/bulk/bulk-upsert-executor.ts

@@ -0,0 +1,93 @@
+import { InsertQueryBuilder } from '../query-builder/insert.js';
+import { findPrimaryKey } from '../query-builder/hydration-planner.js';
+import type { TableDef } from '../schema/table.js';
+import type { OrmSession } from '../orm/orm-session.js';
+import type { BulkUpsertOptions, ChunkOutcome, InsertRow } from './bulk-types.js';
+import type { ValueOperandInput } from '../core/ast/expression.js';
+import type { ColumnNode } from '../core/ast/expression.js';
+import { BulkBaseExecutor, type BulkExecutorOptions } from './bulk-executor.base.js';
+import { resolveReturningColumns, flattenQueryResults, executeCompiled } from './bulk-context.js';
+
+interface UpsertExecutorOptions extends BulkExecutorOptions {
+  conflictColumns?: string[];
+  updateColumns?: string[];
+  returning?: boolean | import('../schema/column-types.js').ColumnDef[];
+}
+
+const DEFAULT_CHUNK_SIZE = 500;
+
+export class BulkUpsertExecutor extends BulkBaseExecutor<UpsertExecutorOptions> {
+  private readonly conflictTargetNodes: ColumnNode[];
+  private readonly updateColumns: string[];
+
+  constructor(
+    session: OrmSession,
+    table: TableDef,
+    rows: InsertRow[],
+    options: BulkUpsertOptions = {}
+  ) {
+    super(session, table, rows, { ...options, chunkSize: options.chunkSize ?? DEFAULT_CHUNK_SIZE });
+
+    const pkName = findPrimaryKey(table);
+    const conflictTargetNames = options.conflictColumns ?? [pkName];
+    this.conflictTargetNodes = conflictTargetNames.map(name => ({
+      type: 'Column' as const,
+      table: table.name,
+      name,
+    }));
+
+    const conflictSet = new Set(conflictTargetNames);
+    this.updateColumns =
+      options.updateColumns ??
+      Object.keys(rows[0] ?? {}).filter(col => !conflictSet.has(col) && col in table.columns);
+  }
+
+  protected async executeChunk(chunk: InsertRow[], _chunkIndex: number): Promise<ChunkOutcome> {
+    const returningColumns = resolveReturningColumns(this.ctx, this.table, this.options.returning);
+
+    const set: Record<string, ValueOperandInput> = {};
+    for (const col of this.updateColumns) {
+      set[col] = { type: 'ExcludedColumn', name: col } as unknown as ValueOperandInput;
+    }
+
+    let builder: InsertQueryBuilder<unknown>;
+
+    if (this.updateColumns.length === 0) {
+      builder = new InsertQueryBuilder(this.table).values(chunk).onConflict(this.conflictTargetNodes).doNothing();
+    } else {
+      builder = new InsertQueryBuilder(this.table)
+        .values(chunk)
+        .onConflict(this.conflictTargetNodes)
+        .doUpdate(set);
+    }
+
+    const finalBuilder = builder as InsertQueryBuilder<unknown>;
+
+    if (returningColumns?.length) {
+      finalBuilder.returning(...returningColumns);
+    }
+
+    const compiled = finalBuilder.compile(this.ctx.dialect);
+    const resultSets = await executeCompiled(this.ctx, compiled);
+
+    return {
+      processedRows: chunk.length,
+      returning: returningColumns ? flattenQueryResults(resultSets) : [],
+      elapsedMs: 0,
+    };
+  }
+}
+
+export async function bulkUpsert<TTable extends TableDef>(
+  session: OrmSession,
+  table: TTable,
+  rows: InsertRow[],
+  options: BulkUpsertOptions = {}
+): Promise<import('./bulk-types.js').BulkResult> {
+  if (!rows.length) {
+    return { processedRows: 0, chunksExecuted: 0, returning: [] };
+  }
+
+  const executor = new BulkUpsertExecutor(session, table, rows, options);
+  return executor.execute();
+}

package/src/bulk/bulk-utils.ts

@@ -0,0 +1,91 @@
+import type { BulkConcurrency, ChunkOutcome, ChunkCompleteInfo, BulkResult } from './bulk-types.js';
+
+export function splitIntoChunks<T>(items: T[], size: number): T[][] {
+  if (size < 1) throw new RangeError(`chunkSize must be >= 1, got ${size}`);
+  const chunks: T[][] = [];
+  for (let i = 0; i < items.length; i += size) {
+    chunks.push(items.slice(i, i + size));
+  }
+  return chunks;
+}
+
+type Task<T> = () => Promise<T>;
+
+export async function runWithConcurrency<T>(
+  tasks: Task<T>[],
+  concurrency: BulkConcurrency
+): Promise<T[]> {
+  const limit = concurrency === 'sequential' ? 1 : Math.max(1, concurrency);
+
+  if (limit === 1) {
+    const results: T[] = [];
+    for (const task of tasks) {
+      results.push(await task());
+    }
+    return results;
+  }
+
+  const results: T[] = new Array(tasks.length);
+  let nextIndex = 0;
+
+  const worker = async (): Promise<void> => {
+    while (nextIndex < tasks.length) {
+      const i = nextIndex++;
+      results[i] = await tasks[i]();
+    }
+  };
+
+  const workers = Array.from({ length: Math.min(limit, tasks.length) }, worker);
+  await Promise.all(workers);
+  return results;
+}
+
+export async function runChunk<T>(
+  task: Task<T>,
+  chunkIndex: number,
+  totalChunks: number,
+  rowsInChunk: number,
+  timing: boolean,
+  onChunkComplete?: (info: ChunkCompleteInfo) => void | Promise<void>
+): Promise<T> {
+  const start = timing || onChunkComplete ? Date.now() : 0;
+  const result = await task();
+  const elapsedMs = start ? Date.now() - start : 0;
+
+  if (onChunkComplete) {
+    await onChunkComplete({ chunkIndex, totalChunks, rowsInChunk, elapsedMs });
+  }
+
+  return result;
+}
+
+export async function maybeTransaction<T>(
+  session: unknown,
+  transactional: boolean,
+  fn: () => Promise<T>
+): Promise<T> {
+  if (!transactional) return fn();
+  const ormSession = session as { transaction: (fn: () => Promise<T>) => Promise<T> };
+  return ormSession.transaction(fn);
+}
+
+export function aggregateOutcomes(outcomes: ChunkOutcome[]): BulkResult {
+  const result: BulkResult = {
+    processedRows: 0,
+    chunksExecuted: outcomes.length,
+    returning: [],
+  };
+
+  for (const o of outcomes) {
+    result.processedRows += o.processedRows;
+    result.returning.push(...o.returning);
+  }
+
+  return result;
+}
+
+export function aggregateOutcomesWithTimings(outcomes: ChunkOutcome[]): BulkResult {
+  const result = aggregateOutcomes(outcomes);
+  result.chunkTimings = outcomes.map(o => o.elapsedMs);
+  return result;
+}

package/src/bulk/index.ts

@@ -0,0 +1,18 @@
+export { bulkInsert, BulkInsertExecutor } from './bulk-insert-executor.js';
+export { bulkUpdate, bulkUpdateWhere, BulkUpdateExecutor } from './bulk-update-executor.js';
+export { bulkDelete, bulkDeleteWhere, BulkDeleteExecutor } from './bulk-delete-executor.js';
+export { bulkUpsert, BulkUpsertExecutor } from './bulk-upsert-executor.js';
+
+export type {
+  BulkResult,
+  BulkBaseOptions,
+  BulkConcurrency,
+  BulkInsertOptions,
+  BulkUpsertOptions,
+  BulkUpdateOptions,
+  BulkDeleteOptions,
+  InsertRow,
+  UpdateRow,
+  ChunkCompleteInfo,
+  ChunkOutcome,
+} from './bulk-types.js';

package/src/codegen/typescript.ts

@@ -2,9 +2,10 @@ import { OrderingTerm, SelectQueryNode } from '../core/ast/query.js';
 import {
   ExpressionNode,
   OperandNode,
-  BinaryExpressionNode,
-  LogicalExpressionNode,
-  InExpressionNode,
+  BinaryExpressionNode,
+  LogicalExpressionNode,
+  NotExpressionNode,
+  InExpressionNode,
   NullExpressionNode,
   JsonPathNode,
   ExistsExpressionNode,
@@ -216,13 +217,17 @@ export class TypeScriptGenerator implements ExpressionVisitor<string>, OperandVi
     return this.printBinaryExpression(binary);
   }
 
-  public visitLogicalExpression(logical: LogicalExpressionNode): string {
-    return this.printLogicalExpression(logical);
-  }
-
-  public visitNullExpression(nullExpr: NullExpressionNode): string {
-    return this.printNullExpression(nullExpr);
-  }
+  public visitLogicalExpression(logical: LogicalExpressionNode): string {
+    return this.printLogicalExpression(logical);
+  }
+
+  public visitNotExpression(notExpr: NotExpressionNode): string {
+    return this.printNotExpression(notExpr);
+  }
+
+  public visitNullExpression(nullExpr: NullExpressionNode): string {
+    return this.printNullExpression(nullExpr);
+  }
 
   public visitInExpression(inExpr: InExpressionNode): string {
     return this.printInExpression(inExpr);
@@ -301,17 +306,21 @@ export class TypeScriptGenerator implements ExpressionVisitor<string>, OperandVi
    * @param logical - Logical expression node
    * @returns TypeScript code representation
    */
-  private printLogicalExpression(logical: LogicalExpressionNode): string {
-    if (logical.operands.length === 0) return '';
-    const parts = logical.operands.map(op => {
-      const compiled = this.printExpression(op);
-      return op.type === 'LogicalExpression' ? `(${compiled})` : compiled;
-    });
-    return `${this.mapOp(logical.operator)}(\n    ${parts.join(',\n    ')}\n  )`;
-  }
-
-  private printArithmeticExpression(expr: ArithmeticExpressionNode): string {
-    const left = this.printOperand(expr.left);
+  private printLogicalExpression(logical: LogicalExpressionNode): string {
+    if (logical.operands.length === 0) return '';
+    const parts = logical.operands.map(op => {
+      const compiled = this.printExpression(op);
+      return op.type === 'LogicalExpression' ? `(${compiled})` : compiled;
+    });
+    return `${this.mapOp(logical.operator)}(\n    ${parts.join(',\n    ')}\n  )`;
+  }
+
+  private printNotExpression(notExpr: NotExpressionNode): string {
+    return `not(${this.printExpression(notExpr.operand)})`;
+  }
+
+  private printArithmeticExpression(expr: ArithmeticExpressionNode): string {
+    const left = this.printOperand(expr.left);
     const right = this.printOperand(expr.right);
     return `${left} ${expr.operator} ${right}`;
   }