kysely 0.27.4 → 0.27.6

package/dist/esm/query-builder/merge-query-builder.d.ts

@@ -1,4 +1,4 @@
-import { AliasedExpression } from '../expression/expression.js';
+import { AliasedExpression, Expression } from '../expression/expression.js';
 import { MergeQueryNode } from '../operation-node/merge-query-node.js';
 import { OperationNodeSource } from '../operation-node/operation-node-source.js';
 import { QueryNode } from '../operation-node/query-node.js';
@@ -23,6 +23,30 @@ import { UpdateQueryBuilder } from './update-query-builder.js';
 export declare class MergeQueryBuilder<DB, TT extends keyof DB, O> implements OutputInterface<DB, TT, O> {
     #private;
     constructor(props: MergeQueryBuilderProps);
+    /**
+     * This can be used to add any additional SQL to the end of the query.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * import { sql } from 'kysely'
+     *
+     * await db
+     *   .mergeInto('person')
+     *   .using('pet', 'pet.owner_id', 'person.id')
+     *   .whenMatched()
+     *   .thenDelete()
+     *   .modifyEnd(sql.raw('-- this is a comment'))
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * merge into "person" using "pet" on "pet"."owner_id" = "person"."id" when matched then delete -- this is a comment
+     * ```
+     */
+    modifyEnd(modifier: Expression<any>): MergeQueryBuilder<DB, TT, O>;
     /**
      * Changes a `merge into` query to an `merge top into` query.
      *
@@ -116,15 +140,24 @@ export declare class MergeQueryBuilder<DB, TT extends keyof DB, O> implements Ou
      *   .output('inserted.id')
      *   .values({
      *     first_name: 'Jennifer',
-     *     last_name: 'Aniston'
+     *     last_name: 'Aniston',
+     *     gender: 'female',
      *   })
-     *   .executeTakeFirst()
+     *   .executeTakeFirstOrThrow()
+     * ```
+     *
+     * The generated SQL (MSSQL):
+     *
+     * ```sql
+     * insert into "person" ("first_name", "last_name", "gender")
+     * output "inserted"."id"
+     * values (@1, @2, @3)
      * ```
      *
      * Return multiple columns:
      *
      * ```ts
-     * const { id, first_name } = await db
+     * const { old_first_name, old_last_name, new_first_name, new_last_name } = await db
      *   .updateTable('person')
      *   .set({ first_name: 'John', last_name: 'Doe' })
      *   .output([
@@ -134,7 +167,19 @@ export declare class MergeQueryBuilder<DB, TT extends keyof DB, O> implements Ou
      *     'inserted.last_name as new_last_name',
      *   ])
      *   .where('created_at', '<', new Date())
-     *   .executeTakeFirst()
+     *   .executeTakeFirstOrThrow()
+     * ```
+     *
+     * The generated SQL (MSSQL):
+     *
+     * ```sql
+     * update "person"
+     * set "first_name" = @1, "last_name" = @2
+     * output "deleted"."first_name" as "old_first_name",
+     *   "deleted"."last_name" as "old_last_name",
+     *   "inserted"."first_name" as "new_first_name",
+     *   "inserted"."last_name" as "new_last_name"
+     * where "created_at" < @3
      * ```
      *
      * Return arbitrary expressions:
@@ -142,11 +187,19 @@ export declare class MergeQueryBuilder<DB, TT extends keyof DB, O> implements Ou
      * ```ts
      * import { sql } from 'kysely'
      *
-     * const { id, full_name } = await db
+     * const { full_name } = await db
      *   .deleteFrom('person')
-     *   .output((eb) => sql<string>`concat(${eb.ref('deleted.first_name')}, ' ', ${eb.ref('deleted.last_name')})`.as('full_name')
+     *   .output((eb) => sql<string>`concat(${eb.ref('deleted.first_name')}, ' ', ${eb.ref('deleted.last_name')})`.as('full_name'))
      *   .where('created_at', '<', new Date())
-     *   .executeTakeFirst()
+     *   .executeTakeFirstOrThrow()
+     * ```
+     *
+     * The generated SQL (MSSQL):
+     *
+     * ```sql
+     * delete from "person"
+     * output concat("deleted"."first_name", ' ', "deleted"."last_name") as "full_name"
+     * where "created_at" < @1
      * ```
      *
      * Return the action performed on the row:
@@ -167,7 +220,21 @@ export declare class MergeQueryBuilder<DB, TT extends keyof DB, O> implements Ou
      *     'inserted.id as inserted_id',
      *     'deleted.id as deleted_id',
      *   ])
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (MSSQL):
+     *
+     * ```sql
+     * merge into "person"
+     * using "pet" on "pet"."owner_id" = "person"."id"
+     * when matched then delete
+     * when not matched then
+     * insert ("first_name", "last_name", "gender")
+     * values (@1, @2, @3)
+     * output "inserted"."id" as "inserted_id", "deleted"."id" as "deleted_id"
      * ```
+     *
      */
     output<OE extends OutputExpression<DB, TT>>(selections: readonly OE[]): MergeQueryBuilder<DB, TT, ReturningRow<DB, TT, O, SelectExpressionFromOutputExpression<OE>>>;
     output<CB extends OutputCallback<DB, TT>>(callback: CB): MergeQueryBuilder<DB, TT, ReturningRow<DB, TT, O, SelectExpressionFromOutputCallback<CB>>>;
@@ -188,6 +255,30 @@ export interface MergeQueryBuilderProps {
 export declare class WheneableMergeQueryBuilder<DB, TT extends keyof DB, ST extends keyof DB, O> implements Compilable<O>, OutputInterface<DB, TT, O>, OperationNodeSource {
     #private;
     constructor(props: MergeQueryBuilderProps);
+    /**
+     * This can be used to add any additional SQL to the end of the query.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * import { sql } from 'kysely'
+     *
+     * await db
+     *   .mergeInto('person')
+     *   .using('pet', 'pet.owner_id', 'person.id')
+     *   .whenMatched()
+     *   .thenDelete()
+     *   .modifyEnd(sql.raw('-- this is a comment'))
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * merge into "person" using "pet" on "pet"."owner_id" = "person"."id" when matched then delete -- this is a comment
+     * ```
+     */
+    modifyEnd(modifier: Expression<any>): WheneableMergeQueryBuilder<DB, TT, ST, O>;
     /**
      * See {@link MergeQueryBuilder.top}.
      */
@@ -376,15 +467,24 @@ export declare class WheneableMergeQueryBuilder<DB, TT extends keyof DB, ST exte
      *   .output('inserted.id')
      *   .values({
      *     first_name: 'Jennifer',
-     *     last_name: 'Aniston'
+     *     last_name: 'Aniston',
+     *     gender: 'female',
      *   })
-     *   .executeTakeFirst()
+     *   .executeTakeFirstOrThrow()
+     * ```
+     *
+     * The generated SQL (MSSQL):
+     *
+     * ```sql
+     * insert into "person" ("first_name", "last_name", "gender")
+     * output "inserted"."id"
+     * values (@1, @2, @3)
      * ```
      *
      * Return multiple columns:
      *
      * ```ts
-     * const { id, first_name } = await db
+     * const { old_first_name, old_last_name, new_first_name, new_last_name } = await db
      *   .updateTable('person')
      *   .set({ first_name: 'John', last_name: 'Doe' })
      *   .output([
@@ -394,7 +494,19 @@ export declare class WheneableMergeQueryBuilder<DB, TT extends keyof DB, ST exte
      *     'inserted.last_name as new_last_name',
      *   ])
      *   .where('created_at', '<', new Date())
-     *   .executeTakeFirst()
+     *   .executeTakeFirstOrThrow()
+     * ```
+     *
+     * The generated SQL (MSSQL):
+     *
+     * ```sql
+     * update "person"
+     * set "first_name" = @1, "last_name" = @2
+     * output "deleted"."first_name" as "old_first_name",
+     *   "deleted"."last_name" as "old_last_name",
+     *   "inserted"."first_name" as "new_first_name",
+     *   "inserted"."last_name" as "new_last_name"
+     * where "created_at" < @3
      * ```
      *
      * Return arbitrary expressions:
@@ -402,11 +514,19 @@ export declare class WheneableMergeQueryBuilder<DB, TT extends keyof DB, ST exte
      * ```ts
      * import { sql } from 'kysely'
      *
-     * const { id, full_name } = await db
+     * const { full_name } = await db
      *   .deleteFrom('person')
-     *   .output((eb) => sql<string>`concat(${eb.ref('deleted.first_name')}, ' ', ${eb.ref('deleted.last_name')})`.as('full_name')
+     *   .output((eb) => sql<string>`concat(${eb.ref('deleted.first_name')}, ' ', ${eb.ref('deleted.last_name')})`.as('full_name'))
      *   .where('created_at', '<', new Date())
-     *   .executeTakeFirst()
+     *   .executeTakeFirstOrThrow()
+     * ```
+     *
+     * The generated SQL (MSSQL):
+     *
+     * ```sql
+     * delete from "person"
+     * output concat("deleted"."first_name", ' ', "deleted"."last_name") as "full_name"
+     * where "created_at" < @1
      * ```
      *
      * Return the action performed on the row:
@@ -427,7 +547,21 @@ export declare class WheneableMergeQueryBuilder<DB, TT extends keyof DB, ST exte
      *     'inserted.id as inserted_id',
      *     'deleted.id as deleted_id',
      *   ])
+     *   .execute()
      * ```
+     *
+     * The generated SQL (MSSQL):
+     *
+     * ```sql
+     * merge into "person"
+     * using "pet" on "pet"."owner_id" = "person"."id"
+     * when matched then delete
+     * when not matched then
+     * insert ("first_name", "last_name", "gender")
+     * values (@1, @2, @3)
+     * output "inserted"."id" as "inserted_id", "deleted"."id" as "deleted_id"
+     * ```
+     *
      */
     output<OE extends OutputExpression<DB, TT>>(selections: readonly OE[]): WheneableMergeQueryBuilder<DB, TT, ST, ReturningRow<DB, TT, O, SelectExpressionFromOutputExpression<OE>>>;
     output<CB extends OutputCallback<DB, TT>>(callback: CB): WheneableMergeQueryBuilder<DB, TT, ST, ReturningRow<DB, TT, O, SelectExpressionFromOutputCallback<CB>>>;
@@ -451,13 +585,15 @@ export declare class WheneableMergeQueryBuilder<DB, TT extends keyof DB, ST exte
      * The next example uses a helper function `log` to log a query:
      *
      * ```ts
+     * import type { Compilable } from 'kysely'
+     *
      * function log<T extends Compilable>(qb: T): T {
      *   console.log(qb.compile())
      *   return qb
      * }
      *
-     * db.updateTable('person')
-     *   .set(values)
+     * await db.updateTable('person')
+     *   .set({ first_name: 'John' })
      *   .$call(log)
      *   .execute()
      * ```
@@ -476,7 +612,9 @@ export declare class WheneableMergeQueryBuilder<DB, TT extends keyof DB, ST exte
      * ### Examples
      *
      * ```ts
-     * async function updatePerson(id: number, updates: UpdateablePerson, returnLastName: boolean) {
+     * import type { PersonUpdate } from 'type-editor' // imaginary module
+     *
+     * async function updatePerson(id: number, updates: PersonUpdate, returnLastName: boolean) {
      *   return await db
      *     .updateTable('person')
      *     .set(updates)
@@ -492,11 +630,11 @@ export declare class WheneableMergeQueryBuilder<DB, TT extends keyof DB, ST exte
      * the code. In the example above the return type of the `updatePerson` function is:
      *
      * ```ts
-     * {
+     * Promise<{
      *   id: number
      *   first_name: string
      *   last_name?: string
-     * }
+     * }>
      * ```
      */
     $if<O2>(condition: boolean, func: (qb: this) => WheneableMergeQueryBuilder<any, any, any, O2>): O2 extends MergeResult ? WheneableMergeQueryBuilder<DB, TT, ST, MergeResult> : O2 extends O & infer E ? WheneableMergeQueryBuilder<DB, TT, ST, O & Partial<E>> : WheneableMergeQueryBuilder<DB, TT, ST, Partial<O2>>;
@@ -603,7 +741,7 @@ export declare class MatchedThenableMergeQueryBuilder<DB, TT extends keyof DB, S
      *   .thenUpdate((ub) => ub
      *     .set(sql`metadata['has_pets']`, 'Y')
      *     .set({
-     *       updated_at: Date.now(),
+     *       updated_at: new Date().toISOString(),
      *     })
      *   )
      *   .execute()

package/dist/esm/query-builder/merge-query-builder.js

@@ -19,6 +19,35 @@ export class MergeQueryBuilder {
     constructor(props) {
         this.#props = freeze(props);
     }
+    /**
+     * This can be used to add any additional SQL to the end of the query.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * import { sql } from 'kysely'
+     *
+     * await db
+     *   .mergeInto('person')
+     *   .using('pet', 'pet.owner_id', 'person.id')
+     *   .whenMatched()
+     *   .thenDelete()
+     *   .modifyEnd(sql.raw('-- this is a comment'))
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * merge into "person" using "pet" on "pet"."owner_id" = "person"."id" when matched then delete -- this is a comment
+     * ```
+     */
+    modifyEnd(modifier) {
+        return new MergeQueryBuilder({
+            ...this.#props,
+            queryNode: QueryNode.cloneWithEndModifier(this.#props.queryNode, modifier.toOperationNode()),
+        });
+    }
     /**
      * Changes a `merge into` query to an `merge top into` query.
      *
@@ -97,6 +126,35 @@ export class WheneableMergeQueryBuilder {
     constructor(props) {
         this.#props = freeze(props);
     }
+    /**
+     * This can be used to add any additional SQL to the end of the query.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * import { sql } from 'kysely'
+     *
+     * await db
+     *   .mergeInto('person')
+     *   .using('pet', 'pet.owner_id', 'person.id')
+     *   .whenMatched()
+     *   .thenDelete()
+     *   .modifyEnd(sql.raw('-- this is a comment'))
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * merge into "person" using "pet" on "pet"."owner_id" = "person"."id" when matched then delete -- this is a comment
+     * ```
+     */
+    modifyEnd(modifier) {
+        return new WheneableMergeQueryBuilder({
+            ...this.#props,
+            queryNode: QueryNode.cloneWithEndModifier(this.#props.queryNode, modifier.toOperationNode()),
+        });
+    }
     /**
      * See {@link MergeQueryBuilder.top}.
      */
@@ -261,13 +319,15 @@ export class WheneableMergeQueryBuilder {
      * The next example uses a helper function `log` to log a query:
      *
      * ```ts
+     * import type { Compilable } from 'kysely'
+     *
      * function log<T extends Compilable>(qb: T): T {
      *   console.log(qb.compile())
      *   return qb
      * }
      *
-     * db.updateTable('person')
-     *   .set(values)
+     * await db.updateTable('person')
+     *   .set({ first_name: 'John' })
      *   .$call(log)
      *   .execute()
      * ```
@@ -288,7 +348,9 @@ export class WheneableMergeQueryBuilder {
      * ### Examples
      *
      * ```ts
-     * async function updatePerson(id: number, updates: UpdateablePerson, returnLastName: boolean) {
+     * import type { PersonUpdate } from 'type-editor' // imaginary module
+     *
+     * async function updatePerson(id: number, updates: PersonUpdate, returnLastName: boolean) {
      *   return await db
      *     .updateTable('person')
      *     .set(updates)
@@ -304,11 +366,11 @@ export class WheneableMergeQueryBuilder {
      * the code. In the example above the return type of the `updatePerson` function is:
      *
      * ```ts
-     * {
+     * Promise<{
      *   id: number
      *   first_name: string
      *   last_name?: string
-     * }
+     * }>
      * ```
      */
     $if(condition, func) {
@@ -459,7 +521,7 @@ export class MatchedThenableMergeQueryBuilder {
      *   .thenUpdate((ub) => ub
      *     .set(sql`metadata['has_pets']`, 'Y')
      *     .set({
-     *       updated_at: Date.now(),
+     *       updated_at: new Date().toISOString(),
      *     })
      *   )
      *   .execute()

package/dist/esm/query-builder/on-conflict-builder.d.ts

@@ -73,6 +73,8 @@ export declare class OnConflictBuilder<DB, TB extends keyof DB> implements Where
      * you can always use:
      *
      * ```ts
+     * import { sql } from 'kysely'
+     *
      * sql`your operator`
      * ```
      *
@@ -84,7 +86,7 @@ export declare class OnConflictBuilder<DB, TB extends keyof DB> implements Where
      * const persons = await db
      *   .selectFrom('person')
      *   .selectAll()
-     *   .where('id', 'in', ['1', '2', '3'])
+     *   .where('id', 'in', [1, 2, 3])
      *   .execute()
      * ```
      *
@@ -332,6 +334,8 @@ export declare class OnConflictBuilder<DB, TB extends keyof DB> implements Where
      * import { sql } from 'kysely'
      * const { ref } = db.dynamic
      *
+     * const columnFromUserInput: string = 'id'
+     *
      * const persons = await db
      *   .selectFrom('person')
      *   .selectAll()
@@ -419,21 +423,25 @@ export declare class OnConflictBuilder<DB, TB extends keyof DB> implements Where
      * ### Examples
      *
      * ```ts
+     * const id = 1
+     * const first_name = 'John'
+     *
      * await db
      *   .insertInto('person')
-     *   .values({ first_name, pic })
+     *   .values({ first_name, id })
      *   .onConflict((oc) => oc
-     *     .column('pic')
+     *     .column('id')
      *     .doNothing()
      *   )
+     *   .execute()
      * ```
      *
      * The generated SQL (PostgreSQL):
      *
      * ```sql
-     * insert into "person" ("first_name", "pic")
+     * insert into "person" ("first_name", "id")
      * values ($1, $2)
-     * on conflict ("pic") do nothing
+     * on conflict ("id") do nothing
      * ```
      */
     doNothing(): OnConflictDoNothingBuilder<DB, TB>;
@@ -443,21 +451,25 @@ export declare class OnConflictBuilder<DB, TB extends keyof DB> implements Where
      * ### Examples
      *
      * ```ts
+     * const id = 1
+     * const first_name = 'John'
+     *
      * await db
      *   .insertInto('person')
-     *   .values({ first_name, pic })
+     *   .values({ first_name, id })
      *   .onConflict((oc) => oc
-     *     .column('pic')
+     *     .column('id')
      *     .doUpdateSet({ first_name })
      *   )
+     *   .execute()
      * ```
      *
      * The generated SQL (PostgreSQL):
      *
      * ```sql
-     * insert into "person" ("first_name", "pic")
+     * insert into "person" ("first_name", "id")
      * values ($1, $2)
-     * on conflict ("pic")
+     * on conflict ("id")
      * do update set "first_name" = $3
      * ```
      *
@@ -466,15 +478,32 @@ export declare class OnConflictBuilder<DB, TB extends keyof DB> implements Where
      * to create an upsert operation:
      *
      * ```ts
-     * db.insertInto('person')
-     *   .values(person)
-     *   .onConflict((oc) => oc
-     *     .column('id')
-     *     .doUpdateSet((eb) => ({
-     *       first_name: eb.ref('excluded.first_name'),
-     *       last_name: eb.ref('excluded.last_name')
-     *     }))
+     * import type { NewPerson } from 'type-editor' // imaginary module
+     *
+     * async function upsertPerson(person: NewPerson): Promise<void> {
+     *   await db.insertInto('person')
+     *     .values(person)
+     *     .onConflict((oc) => oc
+     *       .column('id')
+     *       .doUpdateSet((eb) => ({
+     *         first_name: eb.ref('excluded.first_name'),
+     *         last_name: eb.ref('excluded.last_name')
+     *       })
+     *     )
      *   )
+     *   .execute()
+     * }
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * insert into "person" ("first_name", "last_name")
+     * values ($1, $2)
+     * on conflict ("id")
+     * do update set
+     *  "first_name" = excluded."first_name",
+     *  "last_name" = excluded."last_name"
      * ```
      */
     doUpdateSet(update: UpdateObjectExpression<OnConflictDatabase<DB, TB>, OnConflictTables<TB>, OnConflictTables<TB>>): OnConflictUpdateBuilder<OnConflictDatabase<DB, TB>, OnConflictTables<TB>>;
@@ -537,6 +566,8 @@ export declare class OnConflictUpdateBuilder<DB, TB extends keyof DB> implements
      * you can always use:
      *
      * ```ts
+     * import { sql } from 'kysely'
+     *
      * sql`your operator`
      * ```
      *
@@ -548,7 +579,7 @@ export declare class OnConflictUpdateBuilder<DB, TB extends keyof DB> implements
      * const persons = await db
      *   .selectFrom('person')
      *   .selectAll()
-     *   .where('id', 'in', ['1', '2', '3'])
+     *   .where('id', 'in', [1, 2, 3])
      *   .execute()
      * ```
      *
@@ -796,6 +827,8 @@ export declare class OnConflictUpdateBuilder<DB, TB extends keyof DB> implements
      * import { sql } from 'kysely'
      * const { ref } = db.dynamic
      *
+     * const columnFromUserInput: string = 'id'
+     *
      * const persons = await db
      *   .selectFrom('person')
      *   .selectAll()

package/dist/esm/query-builder/on-conflict-builder.js

@@ -99,21 +99,25 @@ export class OnConflictBuilder {
      * ### Examples
      *
      * ```ts
+     * const id = 1
+     * const first_name = 'John'
+     *
      * await db
      *   .insertInto('person')
-     *   .values({ first_name, pic })
+     *   .values({ first_name, id })
      *   .onConflict((oc) => oc
-     *     .column('pic')
+     *     .column('id')
      *     .doNothing()
      *   )
+     *   .execute()
      * ```
      *
      * The generated SQL (PostgreSQL):
      *
      * ```sql
-     * insert into "person" ("first_name", "pic")
+     * insert into "person" ("first_name", "id")
      * values ($1, $2)
-     * on conflict ("pic") do nothing
+     * on conflict ("id") do nothing
      * ```
      */
     doNothing() {
@@ -130,21 +134,25 @@ export class OnConflictBuilder {
      * ### Examples
      *
      * ```ts
+     * const id = 1
+     * const first_name = 'John'
+     *
      * await db
      *   .insertInto('person')
-     *   .values({ first_name, pic })
+     *   .values({ first_name, id })
      *   .onConflict((oc) => oc
-     *     .column('pic')
+     *     .column('id')
      *     .doUpdateSet({ first_name })
      *   )
+     *   .execute()
      * ```
      *
      * The generated SQL (PostgreSQL):
      *
      * ```sql
-     * insert into "person" ("first_name", "pic")
+     * insert into "person" ("first_name", "id")
      * values ($1, $2)
-     * on conflict ("pic")
+     * on conflict ("id")
      * do update set "first_name" = $3
      * ```
      *
@@ -153,15 +161,32 @@ export class OnConflictBuilder {
      * to create an upsert operation:
      *
      * ```ts
-     * db.insertInto('person')
-     *   .values(person)
-     *   .onConflict((oc) => oc
-     *     .column('id')
-     *     .doUpdateSet((eb) => ({
-     *       first_name: eb.ref('excluded.first_name'),
-     *       last_name: eb.ref('excluded.last_name')
-     *     }))
+     * import type { NewPerson } from 'type-editor' // imaginary module
+     *
+     * async function upsertPerson(person: NewPerson): Promise<void> {
+     *   await db.insertInto('person')
+     *     .values(person)
+     *     .onConflict((oc) => oc
+     *       .column('id')
+     *       .doUpdateSet((eb) => ({
+     *         first_name: eb.ref('excluded.first_name'),
+     *         last_name: eb.ref('excluded.last_name')
+     *       })
+     *     )
      *   )
+     *   .execute()
+     * }
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * insert into "person" ("first_name", "last_name")
+     * values ($1, $2)
+     * on conflict ("id")
+     * do update set
+     *  "first_name" = excluded."first_name",
+     *  "last_name" = excluded."last_name"
      * ```
      */
     doUpdateSet(update) {