Class Kysely<DB>

Creates a delete query.

See the where method for examples on how to specify a where clause for the delete operation.

The return value of the query is an instance of DeleteResult.

Examples

Deleting person with id 1:

const result = await db
  .deleteFrom('person')
  .where('person.id', '=', 1)
  .executeTakeFirst()

console.log(result.numDeletedRows)

The generated SQL (PostgreSQL):

delete from "person" where "person"."id" = $1

Some databases such as MySQL support deleting from multiple tables:

const result = await db
  .deleteFrom(['person', 'pet'])
  .using('person')
  .innerJoin('pet', 'pet.owner_id', '=', 'person.id')
  .where('person.id', '=', 1)
  .executeTakeFirst()

The generated SQL (MySQL):

delete from `person`, `pet`
using `person`
inner join `pet` on `pet`.`owner_id` = `person`.`id`
where `person`.`id` = ?

Creates an insert query.

The return value of this query is an instance of InsertResult. InsertResult has the insertId field that holds the auto incremented id of the inserted row if the db returned one.

See the values method for more info and examples. Also see the returning method for a way to return columns on supported databases like PostgreSQL.

Examples

const result = await db
  .insertInto('person')
  .values({
    first_name: 'Jennifer',
    last_name: 'Aniston'
  })
  .executeTakeFirst()

console.log(result.insertId)

Some databases like PostgreSQL support the returning method:

const { id } = await db
  .insertInto('person')
  .values({
    first_name: 'Jennifer',
    last_name: 'Aniston'
  })
  .returning('id')
  .executeTakeFirst()

Creates a replace query.

A MySQL-only statement similar to onDuplicateKeyUpdate that deletes and inserts values on collision instead of updating existing rows.

The return value of this query is an instance of InsertResult. InsertResult has the insertId field that holds the auto incremented id of the inserted row if the db returned one.

See the values method for more info and examples.

Examples

const result = await db
  .replaceInto('person')
  .values({
    first_name: 'Jennifer',
    last_name: 'Aniston'
  })
  .executeTakeFirst()

console.log(result.insertId)

Creates a select query builder for the given table or tables.

The tables passed to this method are built as the query's from clause.

Examples

Create a select query for one table:

db.selectFrom('person').selectAll()

The generated SQL (PostgreSQL):

select * from "person"

Create a select query for one table with an alias:

const persons = await db.selectFrom('person as p')
  .select(['p.id', 'first_name'])
  .execute()

console.log(persons[0].id)

The generated SQL (PostgreSQL):

select "p"."id", "first_name" from "person" as "p"

Create a select query from a subquery:

const persons = await db.selectFrom(
    (eb) => eb.selectFrom('person').select('person.id as identifier').as('p')
  )
  .select('p.identifier')
  .execute()

console.log(persons[0].identifier)

The generated SQL (PostgreSQL):

select "p"."identifier",
from (
  select "person"."id" as "identifier" from "person"
) as p

Create a select query from raw sql:

import { sql } from 'kysely'

const items = await db
  .selectFrom(sql<{ one: number }>`(select 1 as one)`.as('q'))
  .select('q.one')
  .execute()

console.log(items[0].one)

The generated SQL (PostgreSQL):

select "q"."one",
from (
  select 1 as one
) as q

When you use the sql tag you need to also provide the result type of the raw snippet / query so that Kysely can figure out what columns are available for the rest of the query.

The selectFrom method also accepts an array for multiple tables. All the above examples can also be used in an array.

import { sql } from 'kysely'

const items = await db.selectFrom([
    'person as p',
    db.selectFrom('pet').select('pet.species').as('a'),
    sql<{ one: number }>`(select 1 as one)`.as('q')
  ])
  .select(['p.id', 'a.species', 'q.one'])
  .execute()

The generated SQL (PostgreSQL):

select "p".id, "a"."species", "q"."one"
from
  "person" as "p",
  (select "pet"."species" from "pet") as a,
  (select 1 as one) as "q"

Creates an update query.

See the where method for examples on how to specify a where clause for the update operation.

See the set method for examples on how to specify the updates.

The return value of the query is an UpdateResult.

Examples

const result = await db
  .updateTable('person')
  .set({ first_name: 'Jennifer' })
  .where('person.id', '=', 1)
  .executeTakeFirst()

console.log(result.numUpdatedRows)

Creates a with query (Common Table Expression).

Examples

await db
  .with('jennifers', (db) => db
    .selectFrom('person')
    .where('first_name', '=', 'Jennifer')
    .select(['id', 'age'])
  )
  .with('adult_jennifers', (db) => db
    .selectFrom('jennifers')
    .where('age', '>', 18)
    .select(['id', 'age'])
  )
  .selectFrom('adult_jennifers')
  .where('age', '<', 60)
  .selectAll()
  .execute()

The CTE name can optionally specify column names in addition to a name. In that case Kysely requires the expression to retun rows with the same columns.

await db
  .with('jennifers(id, age)', (db) => db
    .selectFrom('person')
    .where('first_name', '=', 'Jennifer')
    // This is ok since we return columns with the same
    // names as specified by `jennifers(id, age)`.
    .select(['id', 'age'])
  )
  .selectFrom('jennifers')
  .selectAll()
  .execute()

Creates a recursive with query (Common Table Expression).

See the with method for examples and more documentation.

Sets the schema to be used for all table references that don't explicitly specify a schema.

This only affects the query created through the builder returned from this method and doesn't modify the db instance.

See this recipe for a more detailed explanation.

Examples

await db
  .withSchema('mammals')
  .selectFrom('pet')
  .selectAll()
  .innerJoin('public.person', 'public.person.id', 'pet.owner_id')
  .execute()

The generated SQL (PostgreSQL):

select * from "mammals"."pet"
inner join "public"."person"
on "public"."person"."id" = "mammals"."pet"."owner_id"

withSchema is smart enough to not add schema for aliases, common table expressions or other places where the schema doesn't belong to:

await db
  .withSchema('mammals')
  .selectFrom('pet as p')
  .select('p.name')
  .execute()

The generated SQL (PostgreSQL):

select "p"."name" from "mammals"."pet" as "p"