kysely
    Preparing search index...

    Class MergeQueryBuilder<DB, TT, O>

    Type Parameters

    • DB
    • TT extends keyof DB
    • O

    Implements

    Index

    Constructors

    Methods

    • This can be used to add any additional SQL to the end of the query.

      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):

      merge into "person" using "pet" on "pet"."owner_id" = "person"."id" when matched then delete -- this is a comment
      

      Parameters

      Returns MergeQueryBuilder<DB, TT, O>

    • Allows you to return data from modified rows.

      On supported databases like MS SQL Server (MSSQL), this method can be chained to insert, update, delete and merge queries to return data.

      Also see the outputAll method.

      Return one column:

      const { id } = await db
      .insertInto('person')
      .output('inserted.id')
      .values({
      first_name: 'Jennifer',
      last_name: 'Aniston',
      gender: 'female',
      })
      .executeTakeFirstOrThrow()

      The generated SQL (MSSQL):

      insert into "person" ("first_name", "last_name", "gender")
      output "inserted"."id"
      values (@1, @2, @3)

      Return multiple columns:

      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([
      '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', '<', new Date())
      .executeTakeFirstOrThrow()

      The generated SQL (MSSQL):

      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:

      importsql } from 'kysely'

      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'))
      .where('created_at', '<', new Date())
      .executeTakeFirstOrThrow()

      The generated SQL (MSSQL):

      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:

      await db
      .mergeInto('person')
      .using('pet', 'pet.owner_id', 'person.id')
      .whenMatched()
      .thenDelete()
      .whenNotMatched()
      .thenInsertValues({
      first_name: 'John',
      last_name: 'Doe',
      gender: 'male'
      })
      .output([
      'inserted.id as inserted_id',
      'deleted.id as deleted_id',
      ])
      .execute()

      The generated SQL (MSSQL):

      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"

      Type Parameters

      • OE extends
            | AliasedExpression<any, any>
            | `deleted.${string}`
            | `inserted.${string}`
            | `deleted.${string} as ${string}`
            | `inserted.${string} as ${string}`
            | AliasedExpressionFactory<
                OutputDatabase<DB, TT, OutputPrefix>,
                OutputPrefix,
            >

      Parameters

      • selections: readonly OE[]

      Returns MergeQueryBuilder<
          DB,
          TT,
          ReturningRow<DB, TT, O, SelectExpressionFromOutputExpression<OE>>,
      >

    • Type Parameters

      Parameters

      • callback: CB

      Returns MergeQueryBuilder<
          DB,
          TT,
          ReturningRow<DB, TT, O, SelectExpressionFromOutputCallback<CB>>,
      >

    • Type Parameters

      • OE extends
            | AliasedExpression<any, any>
            | `deleted.${string}`
            | `inserted.${string}`
            | `deleted.${string} as ${string}`
            | `inserted.${string} as ${string}`
            | AliasedExpressionFactory<
                OutputDatabase<DB, TT, OutputPrefix>,
                OutputPrefix,
            >

      Parameters

      • selection: OE

      Returns MergeQueryBuilder<
          DB,
          TT,
          ReturningRow<DB, TT, O, SelectExpressionFromOutputExpression<OE>>,
      >

    • Changes a merge into query to an merge top into query.

      top clause is only supported by some dialects like MS SQL Server.

      Affect 5 matched rows at most:

      await db.mergeInto('person')
      .top(5)
      .using('pet', 'person.id', 'pet.owner_id')
      .whenMatched()
      .thenDelete()
      .execute()

      The generated SQL (MS SQL Server):

      merge top(5) into "person"
      using "pet" on "person"."id" = "pet"."owner_id"
      when matched then
      delete

      Affect 50% of matched rows:

      await db.mergeInto('person')
      .top(50, 'percent')
      .using('pet', 'person.id', 'pet.owner_id')
      .whenMatched()
      .thenDelete()
      .execute()

      The generated SQL (MS SQL Server):

      merge top(50) percent into "person"
      using "pet" on "person"."id" = "pet"."owner_id"
      when matched then
      delete

      Parameters

      • expression: number | bigint
      • Optionalmodifiers: "percent"

      Returns MergeQueryBuilder<DB, TT, O>