implemented setRef #1413

Author: iam-abdul

src/parser/reference-parser.ts

@@ -109,30 +109,6 @@ export type ExtractColumnNameFromOrderedColumnName<C extends string> =
       : never
     : C
 
-/**
- * Helper type that filters columns by matching their UpdateType against TargetType.
- */
-type FilterMatchingColumns<
-  DB,
-  TB extends keyof DB,
-  Columns extends string,
-  TargetType,
-> = {
-  [C in Columns]: UpdateType<
-    ExtractRawTypeFromReferenceExpression<DB, TB, C>
-  > extends TargetType
-    ? C
-    : never
-}[Columns]
-
-/**
- * Filters reference expressions to only include columns whose type matches the target type.
- * This is useful for type-safe column-to-column operations where both columns must have the same type.
- */
-export type MatchingReferenceExpression<DB, TB extends keyof DB, TargetType> =
-  | FilterMatchingColumns<DB, TB, AnyColumn<DB, TB>, TargetType>
-  | FilterMatchingColumns<DB, TB, AnyColumnWithTable<DB, TB>, TargetType>
-
 export function parseSimpleReferenceExpression(
   exp: SimpleReferenceExpression<any, any>,
 ): SimpleReferenceExpressionNode {

src/parser/update-set-parser.ts

@@ -38,6 +38,14 @@ export type UpdateObjectExpression<
   UT extends keyof DB = TB,
 > = UpdateObject<DB, TB, UT> | UpdateObjectFactory<DB, TB, UT>
 
+export type UpdateObjectWithRef<
+  DB,
+  TB extends keyof DB,
+  UT extends keyof DB = TB,
+> = DrainOuterGeneric<{
+  [C in AnyColumn<DB, UT>]?: ReferenceExpression<DB, TB>
+}>
+
 export type ExtractUpdateTypeFromReferenceExpression<
   DB,
   TB extends keyof DB,
@@ -63,15 +71,33 @@ export function parseUpdate(
 }
 
 export function parseUpdateWithRef(
-  key: ReferenceExpression<any, any>,
-  value: ReferenceExpression<any, any>,
+  ...args:
+    | [ReferenceExpression<any, any>, ReferenceExpression<any, any>]
+    | [UpdateObjectWithRef<any, any, any>]
+): ReadonlyArray<ColumnUpdateNode> {
+  if (args.length === 2) {
+    return [
+      ColumnUpdateNode.create(
+        parseReferenceExpression(args[0]),
+        parseReferenceExpression(args[1]),
+      ),
+    ]
+  }
+
+  return parseUpdateObjectWithRef(args[0])
+}
+
+export function parseUpdateObjectWithRef(
+  update: UpdateObjectWithRef<any, any, any>,
 ): ReadonlyArray<ColumnUpdateNode> {
-  return [
-    ColumnUpdateNode.create(
-      parseReferenceExpression(key),
-      parseReferenceExpression(value),
-    ),
-  ]
+  return Object.entries(update)
+    .filter(([_, value]) => value !== undefined)
+    .map(([key, value]) => {
+      return ColumnUpdateNode.create(
+        ColumnNode.create(key),
+        parseReferenceExpression(value!),
+      )
+    })
 }
 
 export function parseUpdateObjectExpression(

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

@@ -745,47 +745,76 @@ export class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyof DB, O>
   }
 
   /**
-   * Sets a column to the value of another column with type-safe column matching.
+   * Sets the values to update for an {@link Kysely.updateTable | update} query
+   * using column references instead of values.
    *
-   * Unlike {@link set}, this method only allows you to reference columns that have
-   * the same type as the target column, ensuring type safety at compile time.
+   * This method is similar to {@link set} but allows you to update columns by
+   * referencing other columns instead of providing literal values. This is useful
+   * when you want to copy values from one column to another or perform updates
+   * based on existing column values.
+   *
+   * You can provide either two arguments (column name and reference) or a single
+   * object where keys are column names and values are column references.
    *
    * ### Examples
    *
+   * Update a column by referencing another column using the two-argument form:
+   *
    * ```ts
-   * await db.updateTable('person')
-   *   .setRef('first_name', 'last_name')
+   * const result = await db
+   *   .updateTable('person')
+   *   .setRef('last_name', 'first_name')
    *   .where('id', '=', 1)
-   *   .execute()
+   *   .executeTakeFirst()
    * ```
    *
    * The generated SQL (PostgreSQL):
    *
    * ```sql
-   * update "person" set "first_name" = "last_name" where "id" = $1
+   * update "person" set "last_name" = "first_name" where "id" = $1
    * ```
    *
-   * Type errors for mismatched types:
+   * You can reference columns from joined tables in a PostgreSQL `from` query:
    *
    * ```ts
-   * await db.updateTable('person')
-   *   .setRef('first_name', 'id') // Error: 'id' is number, 'first_name' is string
-   *   .execute()
+   * const result = await db
+   *   .updateTable('person')
+   *   .from('pet')
+   *   .setRef({
+   *     first_name: 'pet.name',
+   *   })
+   *   .whereRef('pet.owner_id', '=', 'person.id')
+   *   .executeTakeFirst()
+   * ```
+   *
+   * The generated SQL (PostgreSQL):
+   *
+   * ```sql
+   * update "person"
+   * set "first_name" = "pet"."name"
+   * from "pet"
+   * where "pet"."owner_id" = "person"."id"
    * ```
    */
   setRef<RE extends ReferenceExpression<DB, UT>>(
     key: RE,
-    value: MatchingReferenceExpression<
-      DB,
-      UT,
-      ExtractUpdateTypeFromReferenceExpression<DB, UT, RE>
-    >,
+    value: RE,
+  ): UpdateQueryBuilder<DB, UT, TB, O>
+
+  setRef(
+    updates: UpdateObjectWithRef<DB, TB, UT>,
+  ): UpdateQueryBuilder<DB, UT, TB, O>
+
+  setRef(
+    ...args:
+      | [ReferenceExpression<DB, UT>, ReferenceExpression<DB, UT>]
+      | [UpdateObjectWithRef<DB, TB, UT>]
   ): UpdateQueryBuilder<DB, UT, TB, O> {
     return new UpdateQueryBuilder({
       ...this.#props,
       queryNode: UpdateQueryNode.cloneWithUpdates(
         this.#props.queryNode,
-        parseUpdateWithRef(key, value),
+        parseUpdateWithRef(...args),
       ),
     })
   }

test/node/src/update.test.ts

@@ -399,6 +399,52 @@ for (const dialect of DIALECTS) {
       expect(jennifer.last_name).to.equal('Jennifer')
     })
 
+    it('should update one row using setRef with object', async () => {
+      const query = ctx.db
+        .updateTable('person')
+        .setRef({
+          last_name: 'first_name',
+        })
+        .where('first_name', '=', 'Jennifer')
+
+      testSql(query, dialect, {
+        postgres: {
+          sql: 'update "person" set "last_name" = "first_name" where "first_name" = $1',
+          parameters: ['Jennifer'],
+        },
+        mysql: {
+          sql: 'update `person` set `last_name` = `first_name` where `first_name` = ?',
+          parameters: ['Jennifer'],
+        },
+        mssql: {
+          sql: 'update "person" set "last_name" = "first_name" where "first_name" = @1',
+          parameters: ['Jennifer'],
+        },
+        sqlite: {
+          sql: 'update "person" set "last_name" = "first_name" where "first_name" = ?',
+          parameters: ['Jennifer'],
+        },
+      })
+
+      const result = await query.executeTakeFirst()
+
+      expect(result).to.be.instanceOf(UpdateResult)
+      expect(result.numUpdatedRows).to.equal(1n)
+      if (sqlSpec === 'mysql') {
+        expect(result.numChangedRows).to.equal(1n)
+      } else {
+        expect(result.numChangedRows).to.undefined
+      }
+
+      const jennifer = await ctx.db
+        .selectFrom('person')
+        .where('first_name', '=', 'Jennifer')
+        .select('last_name')
+        .executeTakeFirstOrThrow()
+
+      expect(jennifer.last_name).to.equal('Jennifer')
+    })
+
     it('should update one row while ignoring undefined values', async () => {
       const query = ctx.db
         .updateTable('person')

test/typings/test-d/update.test-d.ts

@@ -69,6 +69,20 @@ async function testUpdate(db: Kysely<Database>) {
       .setRef('name', 'not_a_column'),
   )
 
+  expectError(
+    db
+      .updateTable('pet as p')
+      .where('p.id', '=', '1')
+      .setRef({ name: 'not_a_column' }),
+  )
+
+  expectError(
+    db
+      .updateTable('pet as p')
+      .where('p.id', '=', '1')
+      .setRef({ not_a_column: 'not_a_column' }),
+  )
+
   // Non-existent column in a callback
   expectError(
     db