kysely
    Preparing search index...

    Interface ReadonlyTransaction<DB>

    Similar to Transaction but read-only.

    interface ReadonlyTransaction<DB> {
        dynamic: DynamicModule<DB>;
        fn: FunctionModule<DB, keyof DB>;
        introspection: DatabaseIntrospector;
        isTransaction: true;
        schema: KyselyTypeError<"not allowed with a read-only Kysely instance.">;
        $extendTables<T extends Record<string, Record<string, any>>>(): ReadonlyTransaction<
            DrainOuterGeneric<DB & T>,
        >;
        $omitTables<T extends string | number | symbol>(): ReadonlyTransaction<
            DB extends object ? Omit<DB, T> : DB,
        >;
        $pickTables<T extends string | number | symbol>(): ReadonlyTransaction<
            DB extends object ? Pick<DB, T> : DB,
        >;
        case(): CaseBuilder<DB, keyof DB>;
        case<V>(value: Expression<V>): CaseBuilder<DB, keyof DB, V>;
        connection(): never;
        deleteFrom(
            ...args: any[],
        ): KyselyTypeError<"not allowed with a read-only Kysely instance.">;
        destroy(): never;
        executeQuery<R>(
            query: ReadonlyCompiledQuery<R> | SelectQueryBuilder<DB, any, R>,
            options?: AbortableQueryOptions,
        ): Promise<ReadonlyQueryResult<R>>;
        executeQuery(
            ...args: any[],
        ): KyselyTypeError<"not allowed with a read-only Kysely instance.">;
        getExecutor(
            ...args: any[],
        ): KyselyTypeError<"not allowed with a read-only Kysely instance.">;
        insertInto(
            ...args: any[],
        ): KyselyTypeError<"not allowed with a read-only Kysely instance.">;
        mergeInto(
            ...args: any[],
        ): KyselyTypeError<"not allowed with a read-only Kysely instance.">;
        replaceInto(
            ...args: any[],
        ): KyselyTypeError<"not allowed with a read-only Kysely instance.">;
        selectFrom<
            TE extends
                | string
                | AliasedExpression<any, any>
                | AliasedDynamicTableBuilder<any, any>
                | AliasedExpressionFactory<DB, never>
                | readonly TableExpression<DB, never>[],
        >(
            from: TE,
        ): SelectFrom<DB, never, TE>;
        selectNoFrom<SE extends SelectExpression<DB, never>>(
            selections: readonly SE[],
        ): SelectQueryBuilder<DB, never, Selection<DB, never, SE>>;
        selectNoFrom<const CB extends SelectCallback<DB, never>>(
            callback: CB,
        ): SelectQueryBuilder<DB, never, CallbackSelection<DB, never, CB>>;
        selectNoFrom<SE extends SelectExpression<DB, never>>(
            selection: SE,
        ): SelectQueryBuilder<DB, never, Selection<DB, never, SE>>;
        startTransaction(): never;
        transaction(): never;
        updateTable(
            ...args: any[],
        ): KyselyTypeError<"not allowed with a read-only Kysely instance.">;
        with<N extends string, E extends ReadonlyCommonTableExpression<DB, N>>(
            nameOrBuilder: N | CTEBuilderCallback<N>,
            expression: E,
        ): ReadonlyQueryCreatorWithCommonTableExpression<DB, N, E>;
        withoutPlugins(): ReadonlyTransaction<DB>;
        withPlugin(plugin: KyselyPlugin): ReadonlyTransaction<DB>;
        withRecursive<
            N extends string,
            E extends ReadonlyRecursiveCommonTableExpression<DB, N>,
        >(
            nameOrBuilder: N | CTEBuilderCallback<N>,
            expression: E,
        ): ReadonlyQueryCreatorWithCommonTableExpression<DB, N, E>;
        withSchema(schema: string): ReadonlyTransaction<DB>;
        withTables<T extends Record<string, Record<string, any>>>(): ReadonlyTransaction<
            DrainOuterGeneric<DB & T>,
        >;
    }

    Type Parameters

    • DB

    Hierarchy (View Summary)

    • Pick<
          ReadonlyKysely<DB>,

              | "case"
              | "deleteFrom"
              | "dynamic"
              | "executeQuery"
              | "fn"
              | "getExecutor"
              | "insertInto"
              | "introspection"
              | "mergeInto"
              | "replaceInto"
              | "schema"
              | "selectFrom"
              | "selectNoFrom"
              | "updateTable"
              | "with"
              | "withRecursive",
      >
    • Pick<
          Transaction<DB>,

              | "connection"
              | "destroy"
              | "isTransaction"
              | "startTransaction"
              | "transaction",
      >
    Index

    Properties

    dynamic fn introspection isTransaction schema

    Methods

    $extendTables $omitTables $pickTables case connection deleteFrom destroy executeQuery getExecutor insertInto mergeInto replaceInto selectFrom selectNoFrom startTransaction transaction updateTable with withoutPlugins withPlugin withRecursive withSchema withTables

    Properties

    dynamic: DynamicModule<DB>
    fn: FunctionModule<DB, keyof DB>
    introspection: DatabaseIntrospector
    isTransaction: true
    schema: KyselyTypeError<"not allowed with a read-only Kysely instance.">

    Methods

    • Returns never

      calling the connection method for a Transaction is not supported

    • Returns never

      calling the destroy method for a Transaction is not supported

    • Parameters

      • ...args: any[]

      Returns KyselyTypeError<"not allowed with a read-only Kysely instance.">

      not allowed with a read-only Kysely instance.

    • 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.

      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"

      Type Parameters

      Parameters

      Returns SelectFrom<DB, never, TE>

    • Creates a select query builder without a from clause.

      If you want to create a select from query, use the selectFrom method instead. This one can be used to create a plain select statement without a from clause.

      This method accepts the same inputs as SelectQueryBuilder.select. See its documentation for more examples.

      const result = await db.selectNoFrom((eb) => [
        eb.selectFrom('person')
          .select('id')
          .where('first_name', '=', 'Jennifer')
          .limit(1)
          .as('jennifer_id'),
        eb.selectFrom('pet')
          .select('id')
          .where('name', '=', 'Doggo')
          .limit(1)
          .as('doggo_id')
      ])
      .executeTakeFirstOrThrow()

      console.log(result.jennifer_id)
      console.log(result.doggo_id)

      The generated SQL (PostgreSQL):

      select (
        select "id"
        from "person"
        where "first_name" = $1
        limit $2
      ) as "jennifer_id", (
        select "id"
        from "pet"
        where "name" = $3
        limit $4
      ) as "doggo_id"

      Type Parameters

      Parameters

      • selections: readonly SE[]

      Returns SelectQueryBuilder<DB, never, Selection<DB, never, SE>>

    • Creates a select query builder without a from clause.

      If you want to create a select from query, use the selectFrom method instead. This one can be used to create a plain select statement without a from clause.

      This method accepts the same inputs as SelectQueryBuilder.select. See its documentation for more examples.

      const result = await db.selectNoFrom((eb) => [
        eb.selectFrom('person')
          .select('id')
          .where('first_name', '=', 'Jennifer')
          .limit(1)
          .as('jennifer_id'),
        eb.selectFrom('pet')
          .select('id')
          .where('name', '=', 'Doggo')
          .limit(1)
          .as('doggo_id')
      ])
      .executeTakeFirstOrThrow()

      console.log(result.jennifer_id)
      console.log(result.doggo_id)

      The generated SQL (PostgreSQL):

      select (
        select "id"
        from "person"
        where "first_name" = $1
        limit $2
      ) as "jennifer_id", (
        select "id"
        from "pet"
        where "name" = $3
        limit $4
      ) as "doggo_id"

      Type Parameters

      Parameters

      • callback: CB

      Returns SelectQueryBuilder<DB, never, CallbackSelection<DB, never, CB>>

    • Creates a select query builder without a from clause.

      If you want to create a select from query, use the selectFrom method instead. This one can be used to create a plain select statement without a from clause.

      This method accepts the same inputs as SelectQueryBuilder.select. See its documentation for more examples.

      const result = await db.selectNoFrom((eb) => [
        eb.selectFrom('person')
          .select('id')
          .where('first_name', '=', 'Jennifer')
          .limit(1)
          .as('jennifer_id'),
        eb.selectFrom('pet')
          .select('id')
          .where('name', '=', 'Doggo')
          .limit(1)
          .as('doggo_id')
      ])
      .executeTakeFirstOrThrow()

      console.log(result.jennifer_id)
      console.log(result.doggo_id)

      The generated SQL (PostgreSQL):

      select (
        select "id"
        from "person"
        where "first_name" = $1
        limit $2
      ) as "jennifer_id", (
        select "id"
        from "pet"
        where "name" = $3
        limit $4
      ) as "doggo_id"

      Type Parameters

      Parameters

      • selection: SE

      Returns SelectQueryBuilder<DB, never, Selection<DB, never, SE>>

    • Returns never

      calling the controlled transaction method for a Transaction is not supported

    • Returns never

      calling the transaction method for a Transaction is not supported

    Settings

    Member Visibility

    On This Page

    Properties
    Methods