metal-orm 1.1.9 → 1.1.11

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/ddl/introspect/mysql.ts

@@ -98,6 +98,31 @@ const databaseFunction: FunctionNode = {
   args: []
 };
 
+const readMysqlField = (row: object, field: string): unknown => {
+  const record = row as Record<string, unknown>;
+
+  if (Object.prototype.hasOwnProperty.call(record, field)) {
+    return record[field];
+  }
+
+  const lower = field.toLowerCase();
+  if (lower !== field && Object.prototype.hasOwnProperty.call(record, lower)) {
+    return record[lower];
+  }
+
+  const upper = field.toUpperCase();
+  if (upper !== field && Object.prototype.hasOwnProperty.call(record, upper)) {
+    return record[upper];
+  }
+
+  return undefined;
+};
+
+const readMysqlStringField = (row: object, field: string): string | undefined => {
+  const value = readMysqlField(row, field);
+  return typeof value === 'string' ? value : undefined;
+};
+
 /**
  * Schema introspector for MySQL.
  * Queries information_schema tables to extract schema metadata.
@@ -254,30 +279,58 @@ export const mysqlIntrospector: SchemaIntrospector = {
 
     const tableComments = new Map<string, string>();
     tableRows.forEach(r => {
-      const key = `${r.table_schema}.${r.table_name}`;
-      if (r.table_comment) {
-        tableComments.set(key, r.table_comment);
+      const tableSchema = readMysqlStringField(r, 'table_schema');
+      const tableName = readMysqlStringField(r, 'table_name');
+      const tableComment = readMysqlStringField(r, 'table_comment');
+      if (!tableSchema || !tableName) return;
+      const key = `${tableSchema}.${tableName}`;
+      if (tableComment) {
+        tableComments.set(key, tableComment);
       }
     });
 
     const pkMap = new Map<string, string[]>();
     pkRows.forEach(r => {
-      const key = `${r.table_schema}.${r.table_name}`;
+      const tableSchema = readMysqlStringField(r, 'table_schema');
+      const tableName = readMysqlStringField(r, 'table_name');
+      const columnName = readMysqlStringField(r, 'column_name');
+      if (!tableSchema || !tableName || !columnName) return;
+      const key = `${tableSchema}.${tableName}`;
       const list = pkMap.get(key) || [];
-      list.push(r.column_name);
+      list.push(columnName);
       pkMap.set(key, list);
     });
 
     const fkMap = new Map<string, MysqlForeignKeyEntry[]>();
     fkRows.forEach(r => {
-      const key = `${r.table_schema}.${r.table_name}.${r.column_name}`;
+      const tableSchema = readMysqlStringField(r, 'table_schema');
+      const tableName = readMysqlStringField(r, 'table_name');
+      const columnName = readMysqlStringField(r, 'column_name');
+      const constraintName = readMysqlStringField(r, 'constraint_name');
+      const referencedTableSchema = readMysqlStringField(r, 'referenced_table_schema');
+      const referencedTableName = readMysqlStringField(r, 'referenced_table_name');
+      const referencedColumnName = readMysqlStringField(r, 'referenced_column_name');
+      const deleteRule = readMysqlStringField(r, 'delete_rule');
+      const updateRule = readMysqlStringField(r, 'update_rule');
+      if (
+        !tableSchema ||
+        !tableName ||
+        !columnName ||
+        !constraintName ||
+        !referencedTableSchema ||
+        !referencedTableName ||
+        !referencedColumnName
+      ) {
+        return;
+      }
+      const key = `${tableSchema}.${tableName}.${columnName}`;
       const list = fkMap.get(key) || [];
       list.push({
-        table: `${r.referenced_table_schema}.${r.referenced_table_name}`,
-        column: r.referenced_column_name,
-        onDelete: r.delete_rule,
-        onUpdate: r.update_rule,
-        name: r.constraint_name
+        table: `${referencedTableSchema}.${referencedTableName}`,
+        column: referencedColumnName,
+        onDelete: deleteRule,
+        onUpdate: updateRule,
+        name: constraintName
       });
       fkMap.set(key, list);
     });
@@ -285,12 +338,21 @@ export const mysqlIntrospector: SchemaIntrospector = {
     const tablesByKey = new Map<string, DatabaseTable>();
 
     columnRows.forEach(r => {
-      const key = `${r.table_schema}.${r.table_name}`;
-      if (!shouldIncludeTable(r.table_name, options)) return;
+      const tableSchema = readMysqlStringField(r, 'table_schema');
+      const tableName = readMysqlStringField(r, 'table_name');
+      const columnName = readMysqlStringField(r, 'column_name');
+      const columnType = readMysqlStringField(r, 'column_type') || readMysqlStringField(r, 'data_type');
+      const isNullable = readMysqlStringField(r, 'is_nullable');
+      const columnDefault = readMysqlField(r, 'column_default');
+      const extra = readMysqlStringField(r, 'extra');
+      const columnComment = readMysqlStringField(r, 'column_comment');
+      if (!tableSchema || !tableName || !columnName || !columnType || !isNullable) return;
+      const key = `${tableSchema}.${tableName}`;
+      if (!shouldIncludeTable(tableName, options)) return;
       if (!tablesByKey.has(key)) {
         tablesByKey.set(key, {
-          name: r.table_name,
-          schema: r.table_schema,
+          name: tableName,
+          schema: tableSchema,
           columns: [],
           primaryKey: pkMap.get(key) || [],
           indexes: [],
@@ -298,17 +360,16 @@ export const mysqlIntrospector: SchemaIntrospector = {
         });
       }
       const table = tablesByKey.get(key)!;
-      const columnType = r.column_type || r.data_type;
-      const comment = r.column_comment?.trim() ? r.column_comment : undefined;
+      const comment = columnComment?.trim() ? columnComment : undefined;
       const column: DatabaseColumn = {
-        name: r.column_name,
+        name: columnName,
         type: columnType,
-        notNull: r.is_nullable === 'NO',
-        default: r.column_default ?? undefined,
-        autoIncrement: typeof r.extra === 'string' && r.extra.includes('auto_increment'),
+        notNull: isNullable === 'NO',
+        default: columnDefault ?? undefined,
+        autoIncrement: typeof extra === 'string' && extra.includes('auto_increment'),
         comment
       };
-      const fk = fkMap.get(`${key}.${r.column_name}`)?.[0];
+      const fk = fkMap.get(`${key}.${columnName}`)?.[0];
       if (fk) {
         column.references = {
           table: fk.table,
@@ -322,14 +383,20 @@ export const mysqlIntrospector: SchemaIntrospector = {
     });
 
     indexRows.forEach(r => {
-      const key = `${r.table_schema}.${r.table_name}`;
+      const tableSchema = readMysqlStringField(r, 'table_schema');
+      const tableName = readMysqlStringField(r, 'table_name');
+      const indexName = readMysqlStringField(r, 'index_name');
+      const nonUnique = readMysqlField(r, 'non_unique');
+      const colsValue = readMysqlField(r, 'cols');
+      if (!tableSchema || !tableName || !indexName) return;
+      const key = `${tableSchema}.${tableName}`;
       const table = tablesByKey.get(key);
       if (!table) return;
-      const cols = (typeof r.cols === 'string' ? r.cols.split(',') : []).map(c => ({ column: c.trim() }));
+      const cols = (typeof colsValue === 'string' ? colsValue.split(',') : []).map(c => ({ column: c.trim() }));
       const idx: DatabaseIndex = {
-        name: r.index_name,
+        name: indexName,
         columns: cols,
-        unique: r.non_unique === 0
+        unique: Number(nonUnique) === 0
       };
       table.indexes = table.indexes || [];
       table.indexes.push(idx);
@@ -409,26 +476,36 @@ export const mysqlIntrospector: SchemaIntrospector = {
       const viewsByKey = new Map<string, DatabaseView>();
 
       for (const r of viewRows) {
-        if (!shouldIncludeView(r.table_name, options)) continue;
-        const key = `${r.table_schema}.${r.table_name}`;
+        const tableSchema = readMysqlStringField(r, 'table_schema');
+        const tableName = readMysqlStringField(r, 'table_name');
+        const viewDefinition = readMysqlStringField(r, 'view_definition');
+        if (!tableSchema || !tableName) continue;
+        if (!shouldIncludeView(tableName, options)) continue;
+        const key = `${tableSchema}.${tableName}`;
         viewsByKey.set(key, {
-          name: r.table_name,
-          schema: r.table_schema,
+          name: tableName,
+          schema: tableSchema,
           columns: [],
-          definition: r.view_definition || undefined
+          definition: viewDefinition || undefined
         });
       }
 
       for (const r of viewColumnRows) {
-        const key = `${r.table_schema}.${r.table_name}`;
+        const tableSchema = readMysqlStringField(r, 'table_schema');
+        const tableName = readMysqlStringField(r, 'table_name');
+        const columnName = readMysqlStringField(r, 'column_name');
+        const columnType = readMysqlStringField(r, 'column_type') || readMysqlStringField(r, 'data_type');
+        const isNullable = readMysqlStringField(r, 'is_nullable');
+        const columnComment = readMysqlStringField(r, 'column_comment');
+        if (!tableSchema || !tableName || !columnName || !columnType || !isNullable) continue;
+        const key = `${tableSchema}.${tableName}`;
         const view = viewsByKey.get(key);
         if (!view) continue;
-        const columnType = r.column_type || r.data_type;
         const column: DatabaseColumn = {
-          name: r.column_name,
+          name: columnName,
           type: columnType,
-          notNull: r.is_nullable === 'NO',
-          comment: r.column_comment?.trim() || undefined
+          notNull: isNullable === 'NO',
+          comment: columnComment?.trim() || undefined
         };
         view.columns.push(column);
       }

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})`;
+      }
+    );
   }
 
   /**