feat: Add NULLIF() implementation

src/operation-node/operation-node-transformer.ts

@@ -99,7 +99,6 @@ import type { OrActionNode } from './or-action-node.js'
 import type { CollateNode } from './collate-node.js'
 import type { QueryId } from '../util/query-id.js'
 import type { RenameConstraintNode } from './rename-constraint-node.js'
-
 /**
  * Transforms an operation node tree into another one.
  *

src/operation-node/operation-node-visitor.ts

@@ -324,4 +324,5 @@ export abstract class OperationNodeVisitor {
   protected abstract visitOutput(node: OutputNode): void
   protected abstract visitOrAction(node: OrActionNode): void
   protected abstract visitCollate(node: CollateNode): void
+  protected abstract visitNullIf(node: FunctionNode): void
 }

src/operation-node/operator-node.ts

@@ -73,6 +73,7 @@ export const OPERATORS = [
   ...UNARY_OPERATORS,
   'between',
   'between symmetric',
+  'nullif',
 ] as const
 
 export type ComparisonOperator = (typeof COMPARISON_OPERATORS)[number]

src/query-builder/function-module.ts

@@ -15,6 +15,7 @@ import {
   type StringReference,
   parseReferenceExpressionOrList,
   type ExtractTypeFromStringReference,
+  parseReferenceExpression,
 } from '../parser/reference-parser.js'
 import { parseSelectAll } from '../parser/select-parser.js'
 import type { KyselyTypeError } from '../util/type-error.js'
@@ -29,6 +30,11 @@ import type { SelectQueryBuilderExpression } from '../query-builder/select-query
 import { isString } from '../util/object-utils.js'
 import { parseTable } from '../parser/table-parser.js'
 import type { Selectable, SelectType } from '../util/column-type.js'
+import {
+  isSafeImmediateValue,
+  parseSafeImmediateValue,
+  parseValueExpression,
+} from '../parser/value-parser.js'
 
 /**
  * Helpers for type safe SQL function calls.
@@ -769,6 +775,31 @@ export interface FunctionModule<DB, TB extends keyof DB> {
         ? Simplify<ShallowDehydrateObject<O>>
         : never
   >
+
+  /**
+   * Creates a `nullif` expression.
+   *
+   * ### Examples
+   *
+   * ```ts
+   * const result = await db.selectFrom('person')
+   *   .select(({fn}) => [
+   *      'first_name',
+   *      fn.nullif(sql.lit(1), 1).as('null_if_result'),
+   *   ])
+   *   .execute()
+   * ```
+   *
+   * The generated SQL (PostgreSQL):
+   *
+   * ```sql
+   * select first_name, nullif(1, 1) as null_if_result from "person"
+   * ```
+   */
+  nullif<T extends ReferenceExpression<DB, TB>>(
+    expr1: T,
+    expr2: number | boolean | string | null,
+  ): ExpressionWrapper<DB, TB, T | null>
 }
 
 export function createFunctionModule<DB, TB extends keyof DB>(): FunctionModule<
@@ -860,5 +891,25 @@ export function createFunctionModule<DB, TB extends keyof DB>(): FunctionModule<
         ]),
       )
     },
+
+    nullif<T extends ReferenceExpression<DB, TB>>(
+      expr1: T,
+      expr2: number | boolean | string | null,
+    ): ExpressionWrapper<DB, TB, T | null> {
+      const v1 =
+        typeof expr1 === 'string'
+          ? parseValueExpression(expr1)
+          : isSafeImmediateValue(expr1)
+            ? parseSafeImmediateValue(expr1)
+            : parseReferenceExpression(expr1)
+      const v2 =
+        typeof expr2 === 'string'
+          ? parseValueExpression(expr2)
+          : isSafeImmediateValue(expr2)
+            ? parseSafeImmediateValue(expr2)
+            : parseReferenceExpression(expr2)
+
+      return new ExpressionWrapper(FunctionNode.create('nullif', [v1, v2]))
+    },
   })
 }

src/query-compiler/default-query-compiler.ts

@@ -27,7 +27,6 @@ import type { OrderByItemNode } from '../operation-node/order-by-item-node.js'
 import type { OrderByNode } from '../operation-node/order-by-node.js'
 import { ParensNode } from '../operation-node/parens-node.js'
 import type { PrimitiveValueListNode } from '../operation-node/primitive-value-list-node.js'
-import type { QueryNode } from '../operation-node/query-node.js'
 import { RawNode } from '../operation-node/raw-node.js'
 import type { ReferenceNode } from '../operation-node/reference-node.js'
 import type { ReferencesNode } from '../operation-node/references-node.js'
@@ -117,7 +116,6 @@ import { logOnce } from '../util/log-once.js'
 import type { CollateNode } from '../operation-node/collate-node.js'
 import type { QueryId } from '../util/query-id.js'
 import type { RenameConstraintNode } from '../operation-node/rename-constraint-node.js'
-
 const LIT_WRAP_REGEX = /'/g
 
 export class DefaultQueryCompiler
@@ -942,6 +940,12 @@ export class DefaultQueryCompiler
     this.compileList(node.updates)
   }
 
+  protected override visitNullIf(node: FunctionNode): void {
+    this.append('nullif(')
+    this.compileList(node.arguments)
+    this.append(')')
+  }
+
   protected override visitCreateIndex(node: CreateIndexNode): void {
     this.append('create ')
 

test/node/src/null-if.test.ts

@@ -0,0 +1,46 @@
+import { Kysely, sql } from '../../../dist/cjs'
+
+import {
+  destroyTest,
+  initTest,
+  TestContext,
+  expect,
+  Database,
+  clearDatabase,
+  DIALECTS,
+} from './test-setup.js'
+
+for (const dialect of DIALECTS) {
+  describe(`${dialect} null if`, () => {
+    let ctx: TestContext
+    let db: Kysely<Database>
+
+    before(async function () {
+      ctx = await initTest(this, dialect)
+
+      db = ctx.db as any
+    })
+
+    afterEach(async () => {
+      await clearDatabase(ctx)
+    })
+
+    after(async () => {
+      await destroyTest(ctx)
+    })
+
+    it('should return correct values for NULLIF without selection from a table', async () => {
+      const result = await db
+        .selectNoFrom(({ fn }) => [
+          fn.nullif(sql.lit('2000-01-01'), '2000-01-01').as('null_dates_equal'),
+          fn.nullif(sql.lit(1), 2).as('null_numbers_different'),
+        ])
+        .executeTakeFirstOrThrow()
+
+      expect(result).to.eql({
+        null_dates_equal: null,
+        null_numbers_different: dialect === 'mysql' ? '1' : 1,
+      })
+    })
+  })
+}