add set(key, value) variant of update set function. Closes #672

src/operation-node/column-update-node.ts

@@ -1,10 +1,9 @@
 import { freeze } from '../util/object-utils.js'
-import { ColumnNode } from './column-node.js'
 import { OperationNode } from './operation-node.js'
 
 export interface ColumnUpdateNode extends OperationNode {
   readonly kind: 'ColumnUpdateNode'
-  readonly column: ColumnNode
+  readonly column: OperationNode
   readonly value: OperationNode
 }
 
@@ -16,7 +15,7 @@ export const ColumnUpdateNode = freeze({
     return node.kind === 'ColumnUpdateNode'
   },
 
-  create(column: ColumnNode, value: OperationNode): ColumnUpdateNode {
+  create(column: OperationNode, value: OperationNode): ColumnUpdateNode {
     return freeze({
       kind: 'ColumnUpdateNode',
       column,

src/parser/reference-parser.ts

@@ -15,7 +15,7 @@ import {
   isExpressionOrFactory,
 } from './expression-parser.js'
 import { DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js'
-import { SelectType } from '../util/column-type.js'
+import { SelectType, UpdateType } from '../util/column-type.js'
 import { IdentifierNode } from '../operation-node/identifier-node.js'
 import { OperationNode } from '../operation-node/operation-node.js'
 import { Expression } from '../expression/expression.js'
@@ -55,8 +55,15 @@ export type ExtractTypeFromReferenceExpression<
   TB extends keyof DB,
   RE,
   DV = unknown
+> = SelectType<ExtractRawTypeFromReferenceExpression<DB, TB, RE, DV>>
+
+export type ExtractRawTypeFromReferenceExpression<
+  DB,
+  TB extends keyof DB,
+  RE,
+  DV = unknown
 > = RE extends string
-  ? SelectType<ExtractTypeFromStringReference<DB, TB, RE>>
+  ? ExtractTypeFromStringReference<DB, TB, RE>
   : RE extends SelectQueryBuilderExpression<infer O>
   ? O[keyof O] | null
   : RE extends (qb: any) => SelectQueryBuilderExpression<infer O>

src/parser/update-set-parser.ts

@@ -7,6 +7,11 @@ import {
 import { UpdateKeys, UpdateType } from '../util/column-type.js'
 import { isFunction } from '../util/object-utils.js'
 import { parseValueExpression, ValueExpression } from './value-parser.js'
+import {
+  ExtractRawTypeFromReferenceExpression,
+  parseReferenceExpression,
+  ReferenceExpression,
+} from './reference-parser.js'
 
 export type UpdateObject<DB, TB extends keyof DB, UT extends keyof DB = TB> = {
   [C in UpdateKeys<DB[UT]>]?:
@@ -20,14 +25,38 @@ export type UpdateObjectFactory<
   UT extends keyof DB
 > = (eb: ExpressionBuilder<DB, TB>) => UpdateObject<DB, TB, UT>
 
-export type UpdateExpression<
+export type UpdateObjectExpression<
   DB,
   TB extends keyof DB,
   UT extends keyof DB = TB
 > = UpdateObject<DB, TB, UT> | UpdateObjectFactory<DB, TB, UT>
 
-export function parseUpdateExpression(
-  update: UpdateExpression<any, any, any>
+export type ExtractUpdateTypeFromReferenceExpression<
+  DB,
+  TB extends keyof DB,
+  RE,
+  DV = unknown
+> = UpdateType<ExtractRawTypeFromReferenceExpression<DB, TB, RE, DV>>
+
+export function parseUpdate(
+  ...args:
+    | [UpdateObjectExpression<any, any, any>]
+    | [ReferenceExpression<any, any>, ValueExpression<any, any, any>]
+): ReadonlyArray<ColumnUpdateNode> {
+  if (args.length === 2) {
+    return [
+      ColumnUpdateNode.create(
+        parseReferenceExpression(args[0]),
+        parseValueExpression(args[1])
+      ),
+    ]
+  }
+
+  return parseUpdateObjectExpression(args[0])
+}
+
+export function parseUpdateObjectExpression(
+  update: UpdateObjectExpression<any, any, any>
 ): ReadonlyArray<ColumnUpdateNode> {
   const updateObj = isFunction(update) ? update(expressionBuilder()) : update
 

src/query-builder/insert-query-builder.ts

@@ -21,8 +21,8 @@ import {
   SimplifySingleResult,
 } from '../util/type-utils.js'
 import {
-  UpdateExpression,
-  parseUpdateExpression,
+  UpdateObjectExpression,
+  parseUpdateObjectExpression,
 } from '../parser/update-set-parser.js'
 import { preventAwait } from '../util/prevent-await.js'
 import { Compilable } from '../util/compilable.js'
@@ -531,13 +531,13 @@ export class InsertQueryBuilder<DB, TB extends keyof DB, O>
    * ```
    */
   onDuplicateKeyUpdate(
-    update: UpdateExpression<DB, TB, TB>
+    update: UpdateObjectExpression<DB, TB, TB>
   ): InsertQueryBuilder<DB, TB, O> {
     return new InsertQueryBuilder({
       ...this.#props,
       queryNode: InsertQueryNode.cloneWith(this.#props.queryNode, {
         onDuplicateKey: OnDuplicateKeyNode.create(
-          parseUpdateExpression(update)
+          parseUpdateObjectExpression(update)
         ),
       }),
     })

src/query-builder/on-conflict-builder.ts

@@ -12,8 +12,8 @@ import {
 import { ExpressionOrFactory } from '../parser/expression-parser.js'
 import { ReferenceExpression } from '../parser/reference-parser.js'
 import {
-  UpdateExpression,
-  parseUpdateExpression,
+  UpdateObjectExpression,
+  parseUpdateObjectExpression,
 } from '../parser/update-set-parser.js'
 import { freeze } from '../util/object-utils.js'
 import { preventAwait } from '../util/prevent-await.js'
@@ -227,7 +227,7 @@ export class OnConflictBuilder<DB, TB extends keyof DB>
    * ```
    */
   doUpdateSet(
-    update: UpdateExpression<
+    update: UpdateObjectExpression<
       OnConflictDatabase<DB, TB>,
       OnConflictTables<TB>,
       OnConflictTables<TB>
@@ -236,7 +236,7 @@ export class OnConflictBuilder<DB, TB extends keyof DB>
     return new OnConflictUpdateBuilder({
       ...this.#props,
       onConflictNode: OnConflictNode.cloneWith(this.#props.onConflictNode, {
-        updates: parseUpdateExpression(update),
+        updates: parseUpdateObjectExpression(update),
       }),
     })
   }

src/query-builder/update-query-builder.ts

@@ -36,16 +36,17 @@ import {
 } from '../util/type-utils.js'
 import { UpdateQueryNode } from '../operation-node/update-query-node.js'
 import {
-  parseUpdateExpression,
-  UpdateExpression,
+  UpdateObjectExpression,
   UpdateObject,
   UpdateObjectFactory,
+  ExtractUpdateTypeFromReferenceExpression,
+  parseUpdate,
 } from '../parser/update-set-parser.js'
 import { preventAwait } from '../util/prevent-await.js'
 import { Compilable } from '../util/compilable.js'
 import { QueryExecutor } from '../query-executor/query-executor.js'
 import { QueryId } from '../util/query-id.js'
-import { freeze } from '../util/object-utils.js'
+import { freeze, isObject } from '../util/object-utils.js'
 import { UpdateResult } from './update-result.js'
 import { KyselyPlugin } from '../plugin/kysely-plugin.js'
 import { WhereInterface } from './where-interface.js'
@@ -67,6 +68,11 @@ import {
 import { KyselyTypeError } from '../util/type-error.js'
 import { Streamable } from '../util/streamable.js'
 import { ExpressionOrFactory } from '../parser/expression-parser.js'
+import {
+  ValueExpression,
+  parseValueExpression,
+} from '../parser/value-parser.js'
+import { ColumnUpdateNode } from '../operation-node/column-update-node.js'
 
 export class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyof DB, O>
   implements
@@ -519,12 +525,25 @@ export class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyof DB, O>
     update: UpdateObjectFactory<DB, TB, UT>
   ): UpdateQueryBuilder<DB, UT, TB, O>
 
-  set(update: UpdateExpression<DB, TB, UT>): UpdateQueryBuilder<DB, UT, TB, O> {
+  set<RE extends ReferenceExpression<DB, UT>>(
+    key: RE,
+    value: ValueExpression<
+      DB,
+      TB,
+      ExtractUpdateTypeFromReferenceExpression<DB, UT, RE>
+    >
+  ): UpdateQueryBuilder<DB, UT, TB, O>
+
+  set(
+    ...args:
+      | [UpdateObjectExpression<DB, TB, UT>]
+      | [ReferenceExpression<DB, UT>, ValueExpression<DB, UT, unknown>]
+  ): UpdateQueryBuilder<DB, UT, TB, O> {
     return new UpdateQueryBuilder({
       ...this.#props,
       queryNode: UpdateQueryNode.cloneWithUpdates(
         this.#props.queryNode,
-        parseUpdateExpression(update)
+        parseUpdate(...args)
       ),
     })
   }

test/node/src/update.test.ts

@@ -78,6 +78,52 @@ for (const dialect of DIALECTS) {
       ])
     })
 
+    it('should update one row using the (key, value) variant of `set` method', async () => {
+      const query = ctx.db
+        .updateTable('person')
+        .set('first_name', 'Foo')
+        .set((eb) => eb.ref('last_name'), 'Barson')
+        .where('gender', '=', 'female')
+
+      testSql(query, dialect, {
+        postgres: {
+          sql: 'update "person" set "first_name" = $1, "last_name" = $2 where "gender" = $3',
+          parameters: ['Foo', 'Barson', 'female'],
+        },
+        mysql: {
+          sql: 'update `person` set `first_name` = ?, `last_name` = ? where `gender` = ?',
+          parameters: ['Foo', 'Barson', 'female'],
+        },
+        sqlite: {
+          sql: 'update "person" set "first_name" = ?, "last_name" = ? where "gender" = ?',
+          parameters: ['Foo', 'Barson', 'female'],
+        },
+      })
+
+      const result = await query.executeTakeFirst()
+
+      expect(result).to.be.instanceOf(UpdateResult)
+      expect(result.numUpdatedRows).to.equal(1n)
+      if (dialect === 'mysql') {
+        expect(result.numChangedRows).to.equal(1n)
+      } else {
+        expect(result.numChangedRows).to.undefined
+      }
+
+      expect(
+        await ctx.db
+          .selectFrom('person')
+          .select(['first_name', 'last_name', 'gender'])
+          .orderBy('first_name')
+          .orderBy('last_name')
+          .execute()
+      ).to.eql([
+        { first_name: 'Arnold', last_name: 'Schwarzenegger', gender: 'male' },
+        { first_name: 'Foo', last_name: 'Barson', gender: 'female' },
+        { first_name: 'Sylvester', last_name: 'Stallone', gender: 'male' },
+      ])
+    })
+
     it('should update one row with table alias', async () => {
       const query = ctx.db
         .updateTable('person as p')