metal-orm 1.1.8 → 1.1.10

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

@@ -0,0 +1,95 @@
+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 { UpsertClause } from '../core/ast/query.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, createBulkExecutionContext } from './bulk-context.js';
+import { splitIntoChunks, runWithConcurrency, runChunk, maybeTransaction, aggregateOutcomes, aggregateOutcomesWithTimings } from './bulk-utils.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 any;
+    }
+
+    let builder: InsertQueryBuilder<unknown>;
+
+    if (this.updateColumns.length === 0) {
+      builder = new InsertQueryBuilder(this.table).values(chunk).onConflict(this.conflictTargetNodes as any).doNothing();
+    } else {
+      builder = new InsertQueryBuilder(this.table)
+        .values(chunk)
+        .onConflict(this.conflictTargetNodes as any)
+        .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}`;
   }

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

@@ -9,10 +9,11 @@ import {
   CaseExpressionNode,
   CastExpressionNode,
   BinaryExpressionNode,
-  ExpressionNode,
-  LogicalExpressionNode,
-  NullExpressionNode,
-  InExpressionNode,
+  ExpressionNode,
+  LogicalExpressionNode,
+  NotExpressionNode,
+  NullExpressionNode,
+  InExpressionNode,
   ExistsExpressionNode,
   InExpressionRight,
   ScalarSubqueryNode,
@@ -21,7 +22,8 @@ import {
   AliasRefNode,
   ArithmeticExpressionNode,
   BitwiseExpressionNode,
-  CollateExpressionNode
+  CollateExpressionNode,
+  IsDistinctExpressionNode
 } from './expression-nodes.js';
 
 export type LiteralValue = LiteralNode['value'];
@@ -341,11 +343,28 @@ export const and = (...operands: ExpressionNode[]): LogicalExpressionNode => ({
  *   eq(users.role, 'moderator')
  * );
  */
-export const or = (...operands: ExpressionNode[]): LogicalExpressionNode => ({
-  type: 'LogicalExpression',
-  operator: 'OR',
-  operands
-});
+export const or = (...operands: ExpressionNode[]): LogicalExpressionNode => ({
+  type: 'LogicalExpression',
+  operator: 'OR',
+  operands
+});
+
+/**
+ * Creates a unary NOT expression (`NOT (expr)`).
+ *
+ * @param operand - Expression to negate.
+ * @returns A `NotExpressionNode`.
+ *
+ * @example
+ * not(or(
+ *   eq(users.status, 'inactive'),
+ *   eq(users.role, 'guest')
+ * ));
+ */
+export const not = (operand: ExpressionNode): NotExpressionNode => ({
+  type: 'NotExpression',
+  operand
+});
 
 /**
  * Creates an IS NULL check (`left IS NULL`).
@@ -735,3 +754,81 @@ export const collate = (
   expression: toOperand(expression),
   collation
 });
+
+/**
+ * Creates an `IS DISTINCT FROM` expression.
+ * 
+ * Unlike `neq(a, b)`, this comparison is **null-safe**:
+ * returns `true` when values are different **including** when one
+ * (or both) is `NULL`. Never returns `NULL`.
+ * 
+ * | left  | right | neq   | isDistinctFrom |
+ * |-------|-------|-------|----------------|
+ * | 1     | 2     | true  | true           |
+ * | 1     | 1     | false | false          |
+ * | NULL  | 1     | NULL  | **true**       |
+ * | NULL  | NULL  | NULL  | **false**      |
+ * 
+ * Compilation by dialect:
+ * - PostgreSQL / SQLite / MSSQL → `left IS DISTINCT FROM right`
+ * - MySQL                       → `NOT (left <=> right)`
+ * 
+ * @param left - The left operand.
+ * @param right - The right operand.
+ * @returns An `IsDistinctExpressionNode`.
+ * 
+ * @example
+ * ```ts
+ * // Find users whose email has changed compared to backup
+ * where(isDistinctFrom(users.columns.email, backup.columns.email))
+ * ```
+ */
+export const isDistinctFrom = (
+  left: OperandNode | ColumnRef,
+  right: OperandNode | ColumnRef | LiteralValue
+): IsDistinctExpressionNode => ({
+  type: 'IsDistinctExpression',
+  left: toOperandNode(left),
+  operator: 'IS DISTINCT FROM',
+  right: toOperand(right),
+});
+
+/**
+ * Creates an `IS NOT DISTINCT FROM` expression.
+ * 
+ * The inverse of `isDistinctFrom`. Equivalent to a **null-safe** equality:
+ * returns `true` when values are equal **including** when both
+ * are `NULL`. Never returns `NULL`.
+ * 
+ * | left  | right | eq    | isNotDistinctFrom |
+ * |-------|-------|-------|------------------|
+ * | 1     | 1     | true  | true             |
+ * | 1     | 2     | false | false            |
+ * | NULL  | 1     | NULL  | **false**        |
+ * | NULL  | NULL  | NULL  | **true**         |
+ * 
+ * Compilation by dialect:
+ * - PostgreSQL / SQLite / MSSQL → `left IS NOT DISTINCT FROM right`
+ * - MySQL                       → `left <=> right`
+ * 
+ * @param left - The left operand.
+ * @param right - The right operand.
+ * @returns An `IsDistinctExpressionNode`.
+ * 
+ * @example
+ * ```ts
+ * // Rows where deletedAt is NULL or equal to a specific date
+ * where(isNotDistinctFrom(orders.columns.deletedAt, null))
+ * // → WHERE "orders"."deletedAt" IS NOT DISTINCT FROM NULL
+ * // equivalent to: WHERE deletedAt IS NULL  (but works with any value)
+ * ```
+ */
+export const isNotDistinctFrom = (
+  left: OperandNode | ColumnRef,
+  right: OperandNode | ColumnRef | LiteralValue
+): IsDistinctExpressionNode => ({
+  type: 'IsDistinctExpression',
+  left: toOperandNode(left),
+  operator: 'IS NOT DISTINCT FROM',
+  right: toOperand(right),
+});

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

@@ -233,19 +233,28 @@ export interface BitwiseExpressionNode {
 /**
  * AST node representing a logical expression (AND/OR)
  */
-export interface LogicalExpressionNode {
-  type: 'LogicalExpression';
-  /** Logical operator (AND or OR) */
-  operator: 'AND' | 'OR';
-  /** Operands to combine */
-  operands: ExpressionNode[];
-}
-
-/**
- * AST node representing a null check expression
- */
-export interface NullExpressionNode {
-  type: 'NullExpression';
+export interface LogicalExpressionNode {
+  type: 'LogicalExpression';
+  /** Logical operator (AND or OR) */
+  operator: 'AND' | 'OR';
+  /** Operands to combine */
+  operands: ExpressionNode[];
+}
+
+/**
+ * AST node representing a unary NOT expression
+ */
+export interface NotExpressionNode {
+  type: 'NotExpression';
+  /** Expression to negate */
+  operand: ExpressionNode;
+}
+
+/**
+ * AST node representing a null check expression
+ */
+export interface NullExpressionNode {
+  type: 'NullExpression';
   /** Operand to check for null */
   left: OperandNode;
   /** Null check operator */
@@ -291,15 +300,36 @@ export interface BetweenExpressionNode {
   upper: OperandNode;
 }
 
+/**
+ * AST node representing an IS DISTINCT FROM / IS NOT DISTINCT FROM expression
+ */
+export interface IsDistinctExpressionNode {
+  type: 'IsDistinctExpression';
+
+  /** The operand on the left side. */
+  left: OperandNode;
+
+  /**
+   * `'IS DISTINCT FROM'`     → true when values are different, even if one is NULL.
+   * `'IS NOT DISTINCT FROM'` → true when values are equal, treating NULL = NULL.
+   */
+  operator: 'IS DISTINCT FROM' | 'IS NOT DISTINCT FROM';
+
+  /** The operand on the right side. */
+  right: OperandNode;
+}
+
 /**
  * Union type representing any supported expression node
  */
-export type ExpressionNode =
-  | BinaryExpressionNode
-  | LogicalExpressionNode
-  | NullExpressionNode
-  | InExpressionNode
-  | ExistsExpressionNode
-  | BetweenExpressionNode
-  | ArithmeticExpressionNode
-  | BitwiseExpressionNode;
+export type ExpressionNode =
+  | BinaryExpressionNode
+  | LogicalExpressionNode
+  | NotExpressionNode
+  | NullExpressionNode
+  | InExpressionNode
+  | ExistsExpressionNode
+  | BetweenExpressionNode
+  | ArithmeticExpressionNode
+  | BitwiseExpressionNode
+  | IsDistinctExpressionNode;

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

@@ -1,7 +1,8 @@
 import {
-  BinaryExpressionNode,
-  LogicalExpressionNode,
-  NullExpressionNode,
+  BinaryExpressionNode,
+  LogicalExpressionNode,
+  NotExpressionNode,
+  NullExpressionNode,
   InExpressionNode,
   ExistsExpressionNode,
   BetweenExpressionNode,
@@ -18,21 +19,24 @@ import {
   WindowFunctionNode,
   CollateExpressionNode,
   AliasRefNode,
-  BitwiseExpressionNode
+  BitwiseExpressionNode,
+  IsDistinctExpressionNode
 } from './expression-nodes.js';
 
 /**
  * Visitor for expression nodes
  */
 export interface ExpressionVisitor<R> {
-  visitBinaryExpression?(node: BinaryExpressionNode): R;
-  visitLogicalExpression?(node: LogicalExpressionNode): R;
-  visitNullExpression?(node: NullExpressionNode): R;
+  visitBinaryExpression?(node: BinaryExpressionNode): R;
+  visitLogicalExpression?(node: LogicalExpressionNode): R;
+  visitNotExpression?(node: NotExpressionNode): R;
+  visitNullExpression?(node: NullExpressionNode): R;
   visitInExpression?(node: InExpressionNode): R;
   visitExistsExpression?(node: ExistsExpressionNode): R;
   visitBetweenExpression?(node: BetweenExpressionNode): R;
   visitArithmeticExpression?(node: ArithmeticExpressionNode): R;
   visitBitwiseExpression?(node: BitwiseExpressionNode): R;
+  visitIsDistinctExpression?(node: IsDistinctExpressionNode): R;
   otherwise?(node: ExpressionNode): R;
 }
 
@@ -143,12 +147,15 @@ export const visitExpression = <R>(node: ExpressionNode, visitor: ExpressionVisi
     case 'BinaryExpression':
       if (visitor.visitBinaryExpression) return visitor.visitBinaryExpression(node);
       break;
-    case 'LogicalExpression':
-      if (visitor.visitLogicalExpression) return visitor.visitLogicalExpression(node);
-      break;
-    case 'NullExpression':
-      if (visitor.visitNullExpression) return visitor.visitNullExpression(node);
-      break;
+    case 'LogicalExpression':
+      if (visitor.visitLogicalExpression) return visitor.visitLogicalExpression(node);
+      break;
+    case 'NotExpression':
+      if (visitor.visitNotExpression) return visitor.visitNotExpression(node);
+      break;
+    case 'NullExpression':
+      if (visitor.visitNullExpression) return visitor.visitNullExpression(node);
+      break;
     case 'InExpression':
       if (visitor.visitInExpression) return visitor.visitInExpression(node);
       break;
@@ -164,6 +171,9 @@ export const visitExpression = <R>(node: ExpressionNode, visitor: ExpressionVisi
     case 'BitwiseExpression':
       if (visitor.visitBitwiseExpression) return visitor.visitBitwiseExpression(node);
       break;
+    case 'IsDistinctExpression':
+      if (visitor.visitIsDistinctExpression) return visitor.visitIsDistinctExpression(node);
+      break;
     default:
       break;
   }

package/src/core/dialect/abstract.ts

@@ -8,10 +8,11 @@ import {
   OrderingTerm
 } from '../ast/query.js';
 import {
-  ExpressionNode,
-  BinaryExpressionNode,
-  LogicalExpressionNode,
-  NullExpressionNode,
+  ExpressionNode,
+  BinaryExpressionNode,
+  LogicalExpressionNode,
+  NotExpressionNode,
+  NullExpressionNode,
   InExpressionNode,
   ExistsExpressionNode,
   LiteralNode,
@@ -28,6 +29,7 @@ import {
   BitwiseExpressionNode,
   CollateExpressionNode,
   AliasRefNode,
+  IsDistinctExpressionNode,
   isOperandNode
 } from '../ast/expression.js';
 import { ProcedureCallNode } from '../ast/procedure.js';
@@ -416,19 +418,24 @@ export abstract class Dialect
       return base;
     });
 
-    this.registerExpressionCompiler('LogicalExpression', (logical: LogicalExpressionNode, ctx) => {
-      if (logical.operands.length === 0) return '';
-      const parts = logical.operands.map(op => {
-        const compiled = this.compileExpression(op, ctx);
-        return op.type === 'LogicalExpression' ? `(${compiled})` : compiled;
-      });
-      return parts.join(` ${logical.operator} `);
-    });
-
-    this.registerExpressionCompiler('NullExpression', (nullExpr: NullExpressionNode, ctx) => {
-      const left = this.compileOperand(nullExpr.left, ctx);
-      return `${left} ${nullExpr.operator}`;
-    });
+    this.registerExpressionCompiler('LogicalExpression', (logical: LogicalExpressionNode, ctx) => {
+      if (logical.operands.length === 0) return '';
+      const parts = logical.operands.map(op => {
+        const compiled = this.compileExpression(op, ctx);
+        return op.type === 'LogicalExpression' ? `(${compiled})` : compiled;
+      });
+      return parts.join(` ${logical.operator} `);
+    });
+
+    this.registerExpressionCompiler('NotExpression', (notExpr: NotExpressionNode, ctx) => {
+      const operand = this.compileExpression(notExpr.operand, ctx);
+      return `NOT (${operand})`;
+    });
+
+    this.registerExpressionCompiler('NullExpression', (nullExpr: NullExpressionNode, ctx) => {
+      const left = this.compileOperand(nullExpr.left, ctx);
+      return `${left} ${nullExpr.operator}`;
+    });
 
     this.registerExpressionCompiler('InExpression', (inExpr: InExpressionNode, ctx) => {
       const left = this.compileOperand(inExpr.left, ctx);
@@ -463,6 +470,12 @@ export abstract class Dialect
       const right = this.compileOperand(bitwise.right, ctx);
       return `${left} ${bitwise.operator} ${right}`;
     });
+
+    this.registerExpressionCompiler('IsDistinctExpression', (node: IsDistinctExpressionNode, ctx) => {
+      const left = this.compileOperand(node.left, ctx);
+      const right = this.compileOperand(node.right, ctx);
+      return `${left} ${node.operator} ${right}`;
+    });
   }
 
   private registerDefaultOperandCompilers(): void {

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

@@ -1,8 +1,8 @@
-import { CompilerContext, CompiledProcedureCall } from '../abstract.js';
-import { JsonPathNode } from '../../ast/expression.js';
-import { InsertQueryNode } from '../../ast/query.js';
-import { SqlDialectBase } from '../base/sql-dialect.js';
-import { MysqlFunctionStrategy } from './functions.js';
+import { CompilerContext, CompiledProcedureCall } from '../abstract.js';
+import { JsonPathNode, IsDistinctExpressionNode } from '../../ast/expression.js';
+import { InsertQueryNode } from '../../ast/query.js';
+import { SqlDialectBase } from '../base/sql-dialect.js';
+import { MysqlFunctionStrategy } from './functions.js';
 import { ProcedureCallNode } from '../../ast/procedure.js';
 
 const sanitizeVariableSuffix = (value: string): string =>
@@ -18,6 +18,21 @@ export class MySqlDialect extends SqlDialectBase {
    */
   public constructor() {
     super(new MysqlFunctionStrategy());
+
+    this.registerExpressionCompiler(
+      'IsDistinctExpression',
+      (node: IsDistinctExpressionNode, ctx: CompilerContext): string => {
+        const left = this.compileOperand(node.left, ctx);
+        const right = this.compileOperand(node.right, ctx);
+        const spaceship = `${left} <=> ${right}`;
+
+        if (node.operator === 'IS NOT DISTINCT FROM') {
+          return spaceship;
+        }
+
+        return `NOT (${spaceship})`;
+      }
+    );
   }
 
   /**