Last Updated: 3/10/2026

ExpressionBuilder | kysely

Preparing search index…

ExpressionBuilder

Interface ExpressionBuilder

interface ExpressionBuilder<DB, TB extends keyof DB> {
    get eb(): ExpressionBuilder<DB, TB>;
    get fn(): FunctionModule<DB, TB>;
    and<E extends OperandExpression<SqlBool>>(
        exprs: readonly E[],
    ): ExpressionWrapper<DB, TB, SqlBool>;
    and<E extends Readonly<FilterObject<DB, TB>>>(
        exprs: E,
    ): ExpressionWrapper<DB, TB, SqlBool>;
    between<
        RE extends
            | string
            | Expression<any>
            | DynamicReferenceBuilder<any>
            | SelectQueryBuilderExpression<Record<string, any>>
            | OperandExpressionFactory<DB, TB, any>,
        SE extends any,
        EE extends any,
    >(
        expr: RE,
        start: SE,
        end: EE,
    ): ExpressionWrapper<DB, TB, SqlBool>;
    betweenSymmetric<
        RE extends
            | string
            | Expression<any>
            | DynamicReferenceBuilder<any>
            | SelectQueryBuilderExpression<Record<string, any>>
            | OperandExpressionFactory<DB, TB, any>,
        SE extends any,
        EE extends any,
    >(
        expr: RE,
        start: SE,
        end: EE,
    ): ExpressionWrapper<DB, TB, SqlBool>;
    case(): CaseBuilder<DB, TB>;
    case<C extends string | DynamicReferenceBuilder<any>>(
        column: C,
    ): CaseBuilder<DB, TB, ExtractTypeFromReferenceExpression<DB, TB, C>>;
    case<E extends Expression<any>>(
        expression: E,
    ): CaseBuilder<DB, TB, ExtractTypeFromValueExpression<E>>;
    cast<
        T,
        RE extends

                | string
                | Expression<any>
                | DynamicReferenceBuilder<any>
                | SelectQueryBuilderExpression<Record<string, any>>
                | OperandExpressionFactory<DB, TB, any> = ReferenceExpression<DB, TB>,
    >(
        expr: RE,
        dataType: DataTypeExpression,
    ): ExpressionWrapper<DB, TB, T>;
    exists<
        RE extends
            | string
            | Expression<any>
            | DynamicReferenceBuilder<any>
            | SelectQueryBuilderExpression<Record<string, any>>
            | OperandExpressionFactory<DB, TB, any>,
    >(
        expr: RE,
    ): ExpressionWrapper<DB, TB, SqlBool>;
    jsonPath<$ extends string = never>(): IsNever<$> extends true
        ? KyselyTypeError<
            “You must provide a column reference as this method’s $ generic”,
        >
        : JSONPathBuilder<
            ExtractTypeFromReferenceExpression<DB, TB, $>,
            ExtractTypeFromReferenceExpression<DB, TB, $>,
        >;
    lit<VE extends null | number | boolean>(
        literal: VE,
    ): ExpressionWrapper<DB, TB, VE>;
    neg<
        RE extends
            | string
            | Expression<any>
            | DynamicReferenceBuilder<any>
            | SelectQueryBuilderExpression<Record<string, any>>
            | OperandExpressionFactory<DB, TB, any>,
    >(
        expr: RE,
    ): ExpressionWrapper<
        DB,
        TB,
        ExtractTypeFromReferenceExpression<DB, TB, RE>,
    >;
    not<
        RE extends
            | string
            | Expression<any>
            | DynamicReferenceBuilder<any>
            | SelectQueryBuilderExpression<Record<string, any>>
            | OperandExpressionFactory<DB, TB, any>,
    >(
        expr: RE,
    ): ExpressionWrapper<
        DB,
        TB,
        ExtractTypeFromReferenceExpression<DB, TB, RE>,
    >;
    or<E extends OperandExpression<SqlBool>>(
        exprs: readonly E[],
    ): ExpressionWrapper<DB, TB, SqlBool>;
    or<E extends Readonly<FilterObject<DB, TB>>>(
        exprs: E,
    ): ExpressionWrapper<DB, TB, SqlBool>;
    parens<
        RE extends
            | string
            | Expression<any>
            | DynamicReferenceBuilder<any>
            | SelectQueryBuilderExpression<Record<string, any>>
            | OperandExpressionFactory<DB, TB, any>,
        OP extends BinaryOperatorExpression,
        VE extends any,
    >(
        lhs: RE,
        op: OP,
        rhs: VE,
    ): ExpressionWrapper<
        DB,
        TB,
        OP extends | “match”
        | “is”
        | ”=”
        | ”==”
        | ”!=”
        | ”<>”
        | ”>”
        | ”>=”
        | ”<”
        | ”<=”
        | “in”
        | “not in”
        | “is not”
        | “like”
        | “not like”
        | “ilike”
        | “not ilike”
        | ”@>”
        | ”<@”
        | ”^@”
        | ”&&”
        | ”?”
        | ”?&”
        | ”?|”
        | ”!<”
        | ”!>”
        | ”<=>”
        | ”!”
        | ""
        | ”*”
        | ”!*”
        | ”@@”
        | ”@@@”
        | ”!!”
        | ”<->”
        | “regexp”
        | “is distinct from”
        | “is not distinct from”
            ? SqlBool
            : ExtractTypeFromReferenceExpression<DB, TB, RE>,
    >;
    parens<T>(expr: Expression<T>): ExpressionWrapper<DB, TB, T>;
    ref<RE extends string>(
        reference: RE,
    ): ExpressionWrapper<
        DB,
        TB,
        ExtractTypeFromReferenceExpression<DB, TB, RE>,
    >;
    ref<RE extends string>(
        reference: RE,
        op: JSONOperatorWith$,
    ): JSONPathBuilder<ExtractTypeFromReferenceExpression<DB, TB, RE>>;
    refTuple<
        R1 extends
            | string
            | Expression<any>
            | DynamicReferenceBuilder<any>
            | SelectQueryBuilderExpression<Record<string, any>>
            | OperandExpressionFactory<DB, TB, any>,
        R2 extends
            | string
            | Expression<any>
            | DynamicReferenceBuilder<any>
            | SelectQueryBuilderExpression<Record<string, any>>
            | OperandExpressionFactory<DB, TB, any>,
    >(
        value1: R1,
        value2: R2,
    ): ExpressionWrapper<DB, TB, RefTuple2<DB, TB, R1, R2>>;
    refTuple<
        R1 extends
            | string
            | Expression<any>
            | DynamicReferenceBuilder<any>
            | SelectQueryBuilderExpression<Record<string, any>>
            | OperandExpressionFactory<DB, TB, any>,
        R2 extends
            | string
            | Expression<any>
            | DynamicReferenceBuilder<any>
            | SelectQueryBuilderExpression<Record<string, any>>
            | OperandExpressionFactory<DB, TB, any>,
        R3 extends
            | string
            | Expression<any>
            | DynamicReferenceBuilder<any>
            | SelectQueryBuilderExpression<Record<string, any>>
            | OperandExpressionFactory<DB, TB, any>,
    >(
        value1: R1,
        value2: R2,
        value3: R3,
    ): ExpressionWrapper<DB, TB, RefTuple3<DB, TB, R1, R2, R3>>;
    refTuple<
        R1 extends
            | string
            | Expression<any>
            | DynamicReferenceBuilder<any>
            | SelectQueryBuilderExpression<Record<string, any>>
            | OperandExpressionFactory<DB, TB, any>,
        R2 extends
            | string
            | Expression<any>
            | DynamicReferenceBuilder<any>
            | SelectQueryBuilderExpression<Record<string, any>>
            | OperandExpressionFactory<DB, TB, any>,
        R3 extends
            | string
            | Expression<any>
            | DynamicReferenceBuilder<any>
            | SelectQueryBuilderExpression<Record<string, any>>
            | OperandExpressionFactory<DB, TB, any>,
        R4 extends
            | string
            | Expression<any>
            | DynamicReferenceBuilder<any>
            | SelectQueryBuilderExpression<Record<string, any>>
            | OperandExpressionFactory<DB, TB, any>,
    >(
        value1: R1,
        value2: R2,
        value3: R3,
        value4: R4,
    ): ExpressionWrapper<DB, TB, RefTuple4<DB, TB, R1, R2, R3, R4>>;
    refTuple<
        R1 extends
            | string
            | Expression<any>
            | DynamicReferenceBuilder<any>
            | SelectQueryBuilderExpression<Record<string, any>>
            | OperandExpressionFactory<DB, TB, any>,
        R2 extends
            | string
            | Expression<any>
            | DynamicReferenceBuilder<any>
            | SelectQueryBuilderExpression<Record<string, any>>
            | OperandExpressionFactory<DB, TB, any>,
        R3 extends
            | string
            | Expression<any>
            | DynamicReferenceBuilder<any>
            | SelectQueryBuilderExpression<Record<string, any>>
            | OperandExpressionFactory<DB, TB, any>,
        R4 extends
            | string
            | Expression<any>
            | DynamicReferenceBuilder<any>
            | SelectQueryBuilderExpression<Record<string, any>>
            | OperandExpressionFactory<DB, TB, any>,
        R5 extends
            | string
            | Expression<any>
            | DynamicReferenceBuilder<any>
            | SelectQueryBuilderExpression<Record<string, any>>
            | OperandExpressionFactory<DB, TB, any>,
    >(
        value1: R1,
        value2: R2,
        value3: R3,
        value4: R4,
        value5: R5,
    ): ExpressionWrapper<DB, TB, RefTuple5<DB, TB, R1, R2, R3, R4, R5>>;
    selectFrom<
        TE extends
            | string
            | AliasedExpression<any, any>
            | AliasedDynamicTableBuilder<any, any>
            | AliasedExpressionFactory<DB, TB>
            | readonly TableExpression<DB, TB>[],
    >(
        from: TE,
    ): SelectFrom<DB, TB, TE>;
    table<T extends string>(
        table: T,
    ): ExpressionWrapper<DB, TB, Selectable<DB[T]>>;
    tuple<V1, V2>(
        value1: V1,
        value2: V2,
    ): ExpressionWrapper<DB, TB, ValTuple2<V1, V2>>;
    tuple<V1, V2, V3>(
        value1: V1,
        value2: V2,
        value3: V3,
    ): ExpressionWrapper<DB, TB, ValTuple3<V1, V2, V3>>;
    tuple<V1, V2, V3, V4>(
        value1: V1,
        value2: V2,
        value3: V3,
        value4: V4,
    ): ExpressionWrapper<DB, TB, ValTuple4<V1, V2, V3, V4>>;
    tuple<V1, V2, V3, V4, V5>(
        value1: V1,
        value2: V2,
        value3: V3,
        value4: V4,
        value5: V5,
    ): ExpressionWrapper<DB, TB, ValTuple5<V1, V2, V3, V4, V5>>;
    unary<
        RE extends
            | string
            | Expression<any>
            | DynamicReferenceBuilder<any>
            | SelectQueryBuilderExpression<Record<string, any>>
            | OperandExpressionFactory<DB, TB, any>,
    >(
        op: ”-” | “exists” | “not exists” | “not”,
        expr: RE,
    ): ExpressionWrapper<
        DB,
        TB,
        ExtractTypeFromReferenceExpression<DB, TB, RE>,
    >;
    val<VE>(
        value: VE,
    ): ExpressionWrapper<DB, TB, ExtractTypeFromValueExpression<VE>>;
    withSchema(schema: string): ExpressionBuilder<DB, TB>;
    <
        RE extends
            | string
            | Expression<any>
            | DynamicReferenceBuilder<any>
            | SelectQueryBuilderExpression<Record<string, any>>
            | OperandExpressionFactory<DB, TB, any>,
        OP extends BinaryOperatorExpression,
        VE extends any,
    >(
        lhs: RE,
        op: OP,
        rhs: VE,
    ): ExpressionWrapper<
        DB,
        TB,
        OP extends | “match”
        | “is”
        | ”=”
        | ”==”
        | ”!=”
        | ”<>”
        | ”>”
        | ”>=”
        | ”<”
        | ”<=”
        | “in”
        | “not in”
        | “is not”
        | “like”
        | “not like”
        | “ilike”
        | “not ilike”
        | ”@>”
        | ”<@”
        | ”^@”
        | ”&&”
        | ”?”
        | ”?&”
        | ”?|”
        | ”!<”
        | ”!>”
        | ”<=>”
        | ”!”
        | ""
        | ”*”
        | ”!*”
        | ”@@”
        | ”@@@”
        | ”!!”
        | ”<->”
        | “regexp”
        | “is distinct from”
        | “is not distinct from”
            ? SqlBool
            : OP extends Expression<T>
                ? unknown extends T ? SqlBool : T
                : SelectType<ExtractRawTypeFromReferenceExpression<DB, TB, RE, unknown>>,
    >;
}

Type Parameters

DB
TB extends keyof DB
ExpressionBuilder<
    RE extends
        | string
        | Expression<any>
        | DynamicReferenceBuilder<any>
        | SelectQueryBuilderExpression<Record<string, any>>
        | OperandExpressionFactory<DB, TB, any>,
    OP extends BinaryOperatorExpression,
    VE extends any,

(
    lhs: RE,
    op: OP,
    rhs: VE,
): ExpressionWrapper<
    DB,
    TB,
    OP extends | “match”
    | “is”
    | ”=”
    | ”==”
    | ”!=”
    | ”<>”
    | ”>”
    | ”>=”
    | ”<”
    | ”<=”
    | “in”
    | “not in”
    | “is not”
    | “like”
    | “not like”
    | “ilike”
    | “not ilike”
    | ”@>”
    | ”<@”
    | ”^@”
    | ”&&”
    | ”?”
    | ”?&”
    | ”?|”
    | ”!<”
    | ”!>”
    | ”<=>”
    | ”!”
    | ""
    | ”*”
    | ”!*”
    | ”@@”
    | ”@@@”
    | ”!!”
    | ”<->”
    | “regexp”
    | “is distinct from”
    | “is not distinct from”
        ? SqlBool
        : OP extends Expression<T>
            ? unknown extends T ? SqlBool : T
            : SelectType<ExtractRawTypeFromReferenceExpression<DB, TB, RE, unknown>>,

Creates a binary expression.

This function returns an Expression and can be used pretty much anywhere. See the examples for a couple of possible use cases.

Examples

A simple comparison:
```
const result = await db.selectFrom('person')  
 .selectAll()  
 .where((eb) => eb('first_name', '=', 'Jennifer'))  
 .execute() Copy
```
The generated SQL (PostgreSQL):
```
select * from "person" where "first_name" = $1 Copy
```
By default the third argument is interpreted as a value. To pass in a column reference, you can use ref:
```
const result = await db.selectFrom('person')  
 .selectAll()  
 .where((eb) => eb('first_name', '=', eb.ref('last_name')))  
 .execute() Copy
```
The generated SQL (PostgreSQL):
```
select * from "person" where "first_name" = "last_name" Copy
```
In the following example eb is used to increment an integer column:
```
await db.updateTable('person')  
 .set((eb) => ({  
 age: eb('age', '+', 1)  
 }))  
 .where('id', '=', 3)  
 .execute() Copy
```
The generated SQL (PostgreSQL):
```
update "person" set "age" = "age" + $1 where "id" = $2 Copy
```
As always, expressions can be nested. Both the first and the third argument can be any expression:
```
const result = await db.selectFrom('person')  
 .selectAll()  
 .where((eb) => eb(  
 eb.fn<string>('lower', ['first_name']),  
 'in',  
 eb.selectFrom('pet')  
 .select('pet.name')  
 .where('pet.species', '=', 'cat')  
 ))  
 .execute() Copy
```
The generated SQL (PostgreSQL):
```
select * from "person" where lower("first_name") in ( select "pet"."name" from "pet" where "pet"."species" = $1 ) Copy
```
Type Parameters
- RE extends
      | string
      | Expression<any>
      | DynamicReferenceBuilder<any>
      | SelectQueryBuilderExpression<Record<string, any>>
      | OperandExpressionFactory<DB, TB, any>
- OP extends BinaryOperatorExpression
- VE extends any
Parameters
- lhs: RE
- op: OP
- rhs: VE
Returns ExpressionWrapper< DB, TB, OP extends | “match” | “is” | ”=” | ”==” | ”!=” | ”<>” | ”>” | ”>=” | ”<” | ”<=” | “in” | “not in” | “is not” | “like” | “not like” | “ilike” | “not ilike” | ”@>” | ”<@” | ”^@” | ”&&” | ”?” | ”?&” | ”?|” | ”!<” | ”!>” | ”<=>” | ”!~~” | "~~" | ”*” | ”!*” | ”@@” | ”@@@” | ”!!” | ”<->” | “regexp” | “is distinct from” | “is not distinct from” ? SqlBool : OP extends Expression<T> ? unknown extends T ? SqlBool : T : SelectType<ExtractRawTypeFromReferenceExpression<DB, TB, RE, unknown>>, >
- Defined in kysely/src/expression/expression-builder.ts:173

Index

Accessors

eb fn

Methods

and between betweenSymmetric case cast exists jsonPath lit neg not or parens ref refTuple selectFrom table tuple unary val withSchema

Accessors

eb

get eb(): ExpressionBuilder<DB, TB>

Returns a copy of this expression builder, for destructuring purposes.

Examples


const result = await db.selectFrom('person')  
 .where(({ eb, exists, selectFrom }) =>  
 eb('first_name', '=', 'Jennifer').and(exists(  
 selectFrom('pet').whereRef('owner_id', '=', 'person.id').select('pet.id')  
 ))  
 )  
 .selectAll()  
 .execute() Copy

The generated SQL (PostgreSQL):


select * from "person" where "first_name" = $1 and exists ( select "pet.id" from "pet" where "owner_id" = "person.id" ) Copy

Returns ExpressionBuilder<DB, TB>

Defined in kysely/src/expression/expression-builder.ts:217

fn

get fn(): FunctionModule<DB, TB>

Returns a FunctionModule that can be used to write type safe function calls.

The difference between this and Kysely.fn is that this one is more type safe. You can only refer to columns visible to the part of the query you are building. Kysely.fn allows you to refer to columns in any table of the database even if it doesn’t produce valid SQL.


const result = await db.selectFrom('person')  
 .innerJoin('pet', 'pet.owner_id', 'person.id')  
 .select((eb) => [  
 'person.id',  
 eb.fn.count('pet.id').as('pet_count')  
 ])  
 .groupBy('person.id')  
 .having((eb) => eb.fn.count('pet.id'), '>', 10)  
 .execute() Copy

The generated SQL (PostgreSQL):


select "person"."id", count("pet"."id") as "pet_count" from "person" inner join "pet" on "pet"."owner_id" = "person"."id" group by "person"."id" having count("pet"."id") > $1 Copy

Returns FunctionModule<DB, TB>

Defined in kysely/src/expression/expression-builder.ts:250

Methods

and

and<E extends OperandExpression<SqlBool>>(
exprs: readonly E[],
): ExpressionWrapper<DB, TB, SqlBool>

Combines two or more expressions using the logical and operator.

An empty array produces a true expression.

This function returns an Expression and can be used pretty much anywhere. See the examples for a couple of possible use cases.

Examples

In this example we use and to create a WHERE expr1 AND expr2 AND expr3 statement:
```
const result = await db.selectFrom('person')  
 .selectAll('person')  
 .where((eb) => eb.and([  
 eb('first_name', '=', 'Jennifer'),  
 eb('first_name', '=', 'Arnold'),  
 eb('first_name', '=', 'Sylvester')  
 ]))  
 .execute() Copy
```
The generated SQL (PostgreSQL):
```
select "person".* from "person" where ( "first_name" = $1 and "first_name" = $2 and "first_name" = $3 ) Copy
```
Optionally you can use the simpler object notation if you only need equality comparisons:
```
const result = await db.selectFrom('person')  
 .selectAll('person')  
 .where((eb) => eb.and({  
 first_name: 'Jennifer',  
 last_name: 'Aniston'  
 }))  
 .execute() Copy
```
The generated SQL (PostgreSQL):
```
select "person".* from "person" where ( "first_name" = $1 and "last_name" = $2 ) Copy
```
Type Parameters
- E extends OperandExpression<SqlBool>
Parameters
- exprs: readonly E[]
Returns ExpressionWrapper<DB, TB, SqlBool>
- Defined in kysely/src/expression/expression-builder.ts:983
and<E extends Readonly<FilterObject<DB, TB>>>(
exprs: E,
): ExpressionWrapper<DB, TB, SqlBool>

Type Parameters
- E extends Readonly<FilterObject<DB, TB>>
Parameters
- exprs: E
Returns ExpressionWrapper<DB, TB, SqlBool>
- Defined in kysely/src/expression/expression-builder.ts:987

between

between<
    RE extends
        | string
        | Expression<any>
        | DynamicReferenceBuilder<any>
        | SelectQueryBuilderExpression<Record<string, any>>
        | OperandExpressionFactory<DB, TB, any>,
    SE extends any,
    EE extends any,

(
    expr: RE,
    start: SE,
    end: EE,
): ExpressionWrapper<DB, TB, SqlBool>

Creates a between expression.

Examples
```
const result = await db.selectFrom('person')  
 .selectAll()  
 .where((eb) => eb.between('age', 40, 60))  
 .execute() Copy
```
The generated SQL (PostgreSQL):
```
select * from "person" where "age" between $1 and $2 Copy
```
Type Parameters
- RE extends
      | string
      | Expression<any>
      | DynamicReferenceBuilder<any>
      | SelectQueryBuilderExpression<Record<string, any>>
      | OperandExpressionFactory<DB, TB, any>
- SE extends any
- EE extends any
Parameters
- expr: RE
- start: SE
- end: EE
Returns ExpressionWrapper<DB, TB, SqlBool>
- Defined in kysely/src/expression/expression-builder.ts:885

betweenSymmetric

betweenSymmetric<
    RE extends
        | string
        | Expression<any>
        | DynamicReferenceBuilder<any>
        | SelectQueryBuilderExpression<Record<string, any>>
        | OperandExpressionFactory<DB, TB, any>,
    SE extends any,
    EE extends any,

(
    expr: RE,
    start: SE,
    end: EE,
): ExpressionWrapper<DB, TB, SqlBool>

Creates a between symmetric expression.

Examples
```
const result = await db.selectFrom('person')  
 .selectAll()  
 .where((eb) => eb.betweenSymmetric('age', 40, 60))  
 .execute() Copy
```
The generated SQL (PostgreSQL):
```
select * from "person" where "age" between symmetric $1 and $2 Copy
```
Type Parameters
- RE extends
      | string
      | Expression<any>
      | DynamicReferenceBuilder<any>
      | SelectQueryBuilderExpression<Record<string, any>>
      | OperandExpressionFactory<DB, TB, any>
- SE extends any
- EE extends any
Parameters
- expr: RE
- start: SE
- end: EE
Returns ExpressionWrapper<DB, TB, SqlBool>
- Defined in kysely/src/expression/expression-builder.ts:913

case

case(): CaseBuilder<DB, TB>

Creates a case statement/operator.

Examples

Kitchen sink example with 2 flavors of case operator:


const { title, name } = await db  
 .selectFrom('person')  
 .where('id', '=', 123)  
 .select((eb) => [  
 eb.fn.coalesce('last_name', 'first_name').as('name'),  
 eb  
 .case()  
 .when('gender', '=', 'male')  
 .then('Mr.')  
 .when('gender', '=', 'female')  
 .then(  
 eb  
 .case('marital_status')  
 .when('single')  
 .then('Ms.')  
 .else('Mrs.')  
 .end()  
 )  
 .end()  
 .as('title'),  
 ])  
 .executeTakeFirstOrThrow() Copy

The generated SQL (PostgreSQL):


select coalesce("last_name", "first_name") as "name", case when "gender" = $1 then $2 when "gender" = $3 then case "marital_status" when $4 then $5 else $6 end end as "title" from "person" where "id" = $7 Copy

Returns CaseBuilder<DB, TB>

Defined in kysely/src/expression/expression-builder.ts:349

case<C extends string | DynamicReferenceBuilder<any>>(
column: C,
): CaseBuilder<DB, TB, ExtractTypeFromReferenceExpression<DB, TB, C>>

Type Parameters
- C extends string | DynamicReferenceBuilder<any>
Parameters
- column: C
Returns CaseBuilder<DB, TB, ExtractTypeFromReferenceExpression<DB, TB, C>>
- Defined in kysely/src/expression/expression-builder.ts:351
case<E extends Expression<any>>(
expression: E,
): CaseBuilder<DB, TB, ExtractTypeFromValueExpression<E>>

Type Parameters
- E extends Expression<any>
Parameters
- expression: E
Returns CaseBuilder<DB, TB, ExtractTypeFromValueExpression<E>>
- Defined in kysely/src/expression/expression-builder.ts:355

cast

cast<
    T,
    RE extends

            | string
            | Expression<any>
            | DynamicReferenceBuilder<any>
            | SelectQueryBuilderExpression<Record<string, any>>
            | OperandExpressionFactory<DB, TB, any> = ReferenceExpression<DB, TB>,

(
    expr: RE,
    dataType: DataTypeExpression,
): ExpressionWrapper<DB, TB, T>

Creates a cast(expr as dataType) expression.

Since Kysely can’t know the mapping between JavaScript and database types, you need to provide both explicitly.

Examples
```
const result = await db.selectFrom('person')  
 .select((eb) => [  
 'id',  
 'first_name',  
 eb.cast<number>('age', 'integer').as('age')  
 ])  
 .execute() Copy
```
The generated SQL (PostgreSQL):
```
select cast("age" as integer) as "age" from "person" Copy
```
Type Parameters
- T
- RE extends
      | string
      | Expression<any>
      | DynamicReferenceBuilder<any>
      | SelectQueryBuilderExpression<Record<string, any>>
      | OperandExpressionFactory<DB, TB, any> = ReferenceExpression<DB, TB>
Parameters
- expr: RE
- dataType: DataTypeExpression
Returns ExpressionWrapper<DB, TB, T>
- Defined in kysely/src/expression/expression-builder.ts:1143

exists

exists<
    RE extends
        | string
        | Expression<any>
        | DynamicReferenceBuilder<any>
        | SelectQueryBuilderExpression<Record<string, any>>
        | OperandExpressionFactory<DB, TB, any>,

(
    expr: RE,
): ExpressionWrapper<DB, TB, SqlBool>

Creates an exists operation.

A shortcut for unary('exists', expr).

Type Parameters
- RE extends
      | string
      | Expression<any>
      | DynamicReferenceBuilder<any>
      | SelectQueryBuilderExpression<Record<string, any>>
      | OperandExpressionFactory<DB, TB, any>
Parameters
- expr: RE
Returns ExpressionWrapper<DB, TB, SqlBool>

See

unary
- Defined in kysely/src/expression/expression-builder.ts:852

jsonPath

jsonPath<$ extends string = never>(): IsNever<$> extends true
    ? KyselyTypeError<
        “You must provide a column reference as this method’s $ generic”,
    >
    : JSONPathBuilder<
        ExtractTypeFromReferenceExpression<DB, TB, $>,
        ExtractTypeFromReferenceExpression<DB, TB, $>,
    >

Creates a JSON path expression with provided column as root document (the $).

For a JSON reference expression, see ref.

Examples
```
await db.updateTable('person')  
 .set('profile', (eb) => eb.fn('json_set', [  
 'profile',  
 eb.jsonPath<'profile'>().key('addresses').at('last').key('city'),  
 eb.val('San Diego')  
 ]))  
 .where('id', '=', 3)  
 .execute() Copy
```
The generated SQL (MySQL):
```
update `person` set `profile` = json_set(`profile`, '$.addresses[last].city', $1) where `id` = $2 Copy
```
Type Parameters
- $ extends string = never
Returns IsNever<$> extends true ? KyselyTypeError< “You must provide a column reference as this method’s $ generic”, > : JSONPathBuilder< ExtractTypeFromReferenceExpression<DB, TB, $>, ExtractTypeFromReferenceExpression<DB, TB, $>, >
- Defined in kysely/src/expression/expression-builder.ts:516

lit

lit<VE extends null | number | boolean>(
literal: VE,
): ExpressionWrapper<DB, TB, VE>

Returns a literal value expression.

Just like val but creates a literal value that gets merged in the SQL. To prevent SQL injections, only boolean, number and null values are accepted. If you need string or other literals, use sql.lit instead.

Examples
```
const result = await db.selectFrom('person')  
 .select((eb) => eb.lit(1).as('one'))  
 .execute() Copy
```
The generated SQL (PostgreSQL):
```
select 1 as "one" from "person" Copy
```
Type Parameters
- VE extends null | number | boolean
Parameters
- literal: VE
Returns ExpressionWrapper<DB, TB, VE>
- Defined in kysely/src/expression/expression-builder.ts:799

neg

neg<
    RE extends
        | string
        | Expression<any>
        | DynamicReferenceBuilder<any>
        | SelectQueryBuilderExpression<Record<string, any>>
        | OperandExpressionFactory<DB, TB, any>,

(
    expr: RE,
): ExpressionWrapper<DB, TB, ExtractTypeFromReferenceExpression<DB, TB, RE>>

Creates a negation operation.

A shortcut for unary('-', expr).

Type Parameters
- RE extends
      | string
      | Expression<any>
      | DynamicReferenceBuilder<any>
      | SelectQueryBuilderExpression<Record<string, any>>
      | OperandExpressionFactory<DB, TB, any>
Parameters
- expr: RE
Returns ExpressionWrapper<DB, TB, ExtractTypeFromReferenceExpression<DB, TB, RE>>

See

unary
- Defined in kysely/src/expression/expression-builder.ts:863

not

not<
    RE extends
        | string
        | Expression<any>
        | DynamicReferenceBuilder<any>
        | SelectQueryBuilderExpression<Record<string, any>>
        | OperandExpressionFactory<DB, TB, any>,

(
    expr: RE,
): ExpressionWrapper<DB, TB, ExtractTypeFromReferenceExpression<DB, TB, RE>>

Creates a not operation.

A shortcut for unary('not', expr).

Type Parameters
- RE extends
      | string
      | Expression<any>
      | DynamicReferenceBuilder<any>
      | SelectQueryBuilderExpression<Record<string, any>>
      | OperandExpressionFactory<DB, TB, any>
Parameters
- expr: RE
Returns ExpressionWrapper<DB, TB, ExtractTypeFromReferenceExpression<DB, TB, RE>>

See

unary
- Defined in kysely/src/expression/expression-builder.ts:841

or

or<E extends OperandExpression<SqlBool>>(
exprs: readonly E[],
): ExpressionWrapper<DB, TB, SqlBool>

Combines two or more expressions using the logical or operator.

An empty array produces a false expression.

This function returns an Expression and can be used pretty much anywhere. See the examples for a couple of possible use cases.

Examples

In this example we use or to create a WHERE expr1 OR expr2 OR expr3 statement:
```
const result = await db.selectFrom('person')  
 .selectAll('person')  
 .where((eb) => eb.or([  
 eb('first_name', '=', 'Jennifer'),  
 eb('first_name', '=', 'Arnold'),  
 eb('first_name', '=', 'Sylvester')  
 ]))  
 .execute() Copy
```
The generated SQL (PostgreSQL):
```
select "person".* from "person" where ( "first_name" = $1 or "first_name" = $2 or "first_name" = $3 ) Copy
```
Optionally you can use the simpler object notation if you only need equality comparisons:
```
const result = await db.selectFrom('person')  
 .selectAll('person')  
 .where((eb) => eb.or({  
 first_name: 'Jennifer',  
 last_name: 'Aniston'  
 }))  
 .execute() Copy
```
The generated SQL (PostgreSQL):
```
select "person".* from "person" where ( "first_name" = $1 or "last_name" = $2 ) Copy
```
Type Parameters
- E extends OperandExpression<SqlBool>
Parameters
- exprs: readonly E[]
Returns ExpressionWrapper<DB, TB, SqlBool>
- Defined in kysely/src/expression/expression-builder.ts:1051
or<E extends Readonly<FilterObject<DB, TB>>>(
exprs: E,
): ExpressionWrapper<DB, TB, SqlBool>

Type Parameters
- E extends Readonly<FilterObject<DB, TB>>
Parameters
- exprs: E
Returns ExpressionWrapper<DB, TB, SqlBool>
- Defined in kysely/src/expression/expression-builder.ts:1055

parens

parens<
    RE extends
        | string
        | Expression<any>
        | DynamicReferenceBuilder<any>
        | SelectQueryBuilderExpression<Record<string, any>>
        | OperandExpressionFactory<DB, TB, any>,
    OP extends BinaryOperatorExpression,
    VE extends any,

(
    lhs: RE,
    op: OP,
    rhs: VE,
): ExpressionWrapper<
    DB,
    TB,
    OP extends | “match”
    | “is”
    | ”=”
    | ”==”
    | ”!=”
    | ”<>”
    | ”>”
    | ”>=”
    | ”<”
    | ”<=”
    | “in”
    | “not in”
    | “is not”
    | “like”
    | “not like”
    | “ilike”
    | “not ilike”
    | ”@>”
    | ”<@”
    | ”^@”
    | ”&&”
    | ”?”
    | ”?&”
    | ”?|”
    | ”!<”
    | ”!>”
    | ”<=>”
    | ”!”
    | ""
    | ”*”
    | ”!*”
    | ”@@”
    | ”@@@”
    | ”!!”
    | ”<->”
    | “regexp”
    | “is distinct from”
    | “is not distinct from”
        ? SqlBool
        : ExtractTypeFromReferenceExpression<DB, TB, RE>,

Wraps the expression in parentheses.

Examples
```
const result = await db.selectFrom('person')  
 .selectAll('person')  
 .where((eb) => eb(eb.parens('age', '+', 1), '/', 100), '<', 0.1)  
 .execute() Copy
```
The generated SQL (PostgreSQL):
```
select "person".* from "person" where ("age" + $1) / $2 < $3 Copy
```
You can also pass in any expression as the only argument:
```
const result = await db.selectFrom('person')  
 .selectAll('person')  
 .where((eb) => eb.parens(  
 eb('age', '=', 1).or('age', '=', 2)  
 ).and(  
 eb('first_name', '=', 'Jennifer').or('first_name', '=', 'Arnold')  
 ))  
 .execute() Copy
```
The generated SQL (PostgreSQL):
```
select "person".* from "person" where ("age" = $1 or "age" = $2) and ("first_name" = $3 or "first_name" = $4) Copy
```
Type Parameters
- RE extends
      | string
      | Expression<any>
      | DynamicReferenceBuilder<any>
      | SelectQueryBuilderExpression<Record<string, any>>
      | OperandExpressionFactory<DB, TB, any>
- OP extends BinaryOperatorExpression
- VE extends any
Parameters
- lhs: RE
- op: OP
- rhs: VE
Returns ExpressionWrapper< DB, TB, OP extends | “match” | “is” | ”=” | ”==” | ”!=” | ”<>” | ”>” | ”>=” | ”<” | ”<=” | “in” | “not in” | “is not” | “like” | “not like” | “ilike” | “not ilike” | ”@>” | ”<@” | ”^@” | ”&&” | ”?” | ”?&” | ”?|” | ”!<” | ”!>” | ”<=>” | ”!~~” | "~~" | ”*” | ”!*” | ”@@” | ”@@@” | ”!!” | ”<->” | “regexp” | “is distinct from” | “is not distinct from” ? SqlBool : ExtractTypeFromReferenceExpression<DB, TB, RE>, >
- Defined in kysely/src/expression/expression-builder.ts:1100
parens<T>(expr: Expression<T>): ExpressionWrapper<DB, TB, T>

Type Parameters
- T
Parameters
- expr: Expression<T>
Returns ExpressionWrapper<DB, TB, T>
- Defined in kysely/src/expression/expression-builder.ts:1116

ref

ref<RE extends string>(
reference: RE,
): ExpressionWrapper<DB, TB, ExtractTypeFromReferenceExpression<DB, TB, RE>>

This method can be used to reference columns within the query’s context. For a non-type-safe version of this method see sql’s version.

Additionally, this method can be used to reference nested JSON properties or array elements. See JSONPathBuilder for more information. For regular JSON path expressions you can use jsonPath.

Examples

By default the third argument of binary expressions is a value. This function can be used to pass in a column reference instead:


const result = await db.selectFrom('person')  
 .selectAll('person')  
 .where((eb) => eb.or([  
 eb('first_name', '=', eb.ref('last_name')),  
 eb('first_name', '=', eb.ref('middle_name'))  
 ]))  
 .execute() Copy

The generated SQL (PostgreSQL):


select "person".* from "person" where "first_name" = "last_name" or "first_name" = "middle_name" Copy

In the next example we use the ref method to reference columns of the virtual table excluded in a type-safe way to create an upsert operation:


await db.insertInto('person')  
 .values({  
 id: 3,  
 first_name: 'Jennifer',  
 last_name: 'Aniston',  
 gender: 'female',  
 })  
 .onConflict((oc) => oc  
 .column('id')  
 .doUpdateSet(({ ref }) => ({  
 first_name: ref('excluded.first_name'),  
 last_name: ref('excluded.last_name'),  
 gender: ref('excluded.gender'),  
 }))  
 )  
 .execute() Copy

The generated SQL (PostgreSQL):


insert into "person" ("id", "first_name", "last_name", "gender") values ($1, $2, $3, $4) on conflict ("id") do update set "first_name" = "excluded"."first_name", "last_name" = "excluded"."last_name", "gender" = "excluded"."gender" Copy

In the next example we use ref in a raw sql expression. Unless you want to be as type-safe as possible, this is probably overkill:


import { sql } from 'kysely'  
  
await db.updateTable('pet')  
 .set((eb) => ({  
 name: sql<string>`concat(${eb.ref('pet.name')}, ${' the animal'})`  
 }))  
 .execute() Copy

The generated SQL (PostgreSQL):


update "pet" set "name" = concat("pet"."name", $1) Copy

In the next example we use ref to reference a nested JSON property:


const result = await db.selectFrom('person')  
 .where(({ eb, ref }) => eb(  
 ref('profile', '->').key('addresses').at(0).key('city'),  
 '=',  
 'San Diego'  
 ))  
 .selectAll()  
 .execute() Copy

The generated SQL (PostgreSQL):


select * from "person" where "profile"->'addresses'->0->'city' = $1 Copy

You can also compile to a JSON path expression by using the ->$or ->>$ operator:


const result = await db.selectFrom('person')  
 .select(({ ref }) =>  
 ref('profile', '->$')  
 .key('addresses')  
 .at('last')  
 .key('city')  
 .as('current_city')  
 )  
 .execute() Copy

The generated SQL (MySQL):


select `profile`->'$.addresses[last].city' as `current_city` from `person` Copy

Type Parameters

RE extends string

Parameters

reference: RE

Returns ExpressionWrapper<DB, TB, ExtractTypeFromReferenceExpression<DB, TB, RE>>

Defined in kysely/src/expression/expression-builder.ts:481

ref<RE extends string>(
reference: RE,
op: JSONOperatorWith$,
): JSONPathBuilder<ExtractTypeFromReferenceExpression<DB, TB, RE>>

Type Parameters
- RE extends string
Parameters
- reference: RE
- op: JSONOperatorWith$
Returns JSONPathBuilder<ExtractTypeFromReferenceExpression<DB, TB, RE>>
- Defined in kysely/src/expression/expression-builder.ts:485

refTuple

refTuple<
    R1 extends
        | string
        | Expression<any>
        | DynamicReferenceBuilder<any>
        | SelectQueryBuilderExpression<Record<string, any>>
        | OperandExpressionFactory<DB, TB, any>,
    R2 extends
        | string
        | Expression<any>
        | DynamicReferenceBuilder<any>
        | SelectQueryBuilderExpression<Record<string, any>>
        | OperandExpressionFactory<DB, TB, any>,

(
    value1: R1,
    value2: R2,
): ExpressionWrapper<DB, TB, RefTuple2<DB, TB, R1, R2>>

Creates a tuple expression.

This creates a tuple using column references by default. See tuple if you need to create value tuples.

Examples
```
const result = await db.selectFrom('person')  
 .selectAll('person')  
 .where(({ eb, refTuple, tuple }) => eb(  
 refTuple('first_name', 'last_name'),  
 'in',  
 [  
 tuple('Jennifer', 'Aniston'),  
 tuple('Sylvester', 'Stallone')  
 ]  
 ))  
 .execute() Copy
```
The generated SQL (PostgreSQL):
```
select "person".* from "person" where ("first_name", "last_name") in ( ($1, $2), ($3, $4) ) Copy
```
In the next example a reference tuple is compared to a subquery. Note that in this case you need to use the @SelectQueryBuilder.$asTuple | $asTuple function:
```
const result = await db.selectFrom('person')  
 .selectAll('person')  
 .where(({ eb, refTuple, selectFrom }) => eb(  
 refTuple('first_name', 'last_name'),  
 'in',  
 selectFrom('pet')  
 .select(['name', 'species'])  
 .where('species', '!=', 'cat')  
 .$asTuple('name', 'species')  
 ))  
 .execute() Copy
```
The generated SQL (PostgreSQL):
```
select "person".* from "person" where ("first_name", "last_name") in ( select "name", "species" from "pet" where "species" != $1 ) Copy
```
Type Parameters
- R1 extends
      | string
      | Expression<any>
      | DynamicReferenceBuilder<any>
      | SelectQueryBuilderExpression<Record<string, any>>
      | OperandExpressionFactory<DB, TB, any>
- R2 extends
      | string
      | Expression<any>
      | DynamicReferenceBuilder<any>
      | SelectQueryBuilderExpression<Record<string, any>>
      | OperandExpressionFactory<DB, TB, any>
Parameters
- value1: R1
- value2: R2
Returns ExpressionWrapper<DB, TB, RefTuple2<DB, TB, R1, R2>>
- Defined in kysely/src/expression/expression-builder.ts:670
refTuple<
    R1 extends
        | string
        | Expression<any>
        | DynamicReferenceBuilder<any>
        | SelectQueryBuilderExpression<Record<string, any>>
        | OperandExpressionFactory<DB, TB, any>,
    R2 extends
        | string
        | Expression<any>
        | DynamicReferenceBuilder<any>
        | SelectQueryBuilderExpression<Record<string, any>>
        | OperandExpressionFactory<DB, TB, any>,
    R3 extends
        | string
        | Expression<any>
        | DynamicReferenceBuilder<any>
        | SelectQueryBuilderExpression<Record<string, any>>
        | OperandExpressionFactory<DB, TB, any>,

(
    value1: R1,
    value2: R2,
    value3: R3,
): ExpressionWrapper<DB, TB, RefTuple3<DB, TB, R1, R2, R3>>

Type Parameters
- R1 extends
      | string
      | Expression<any>
      | DynamicReferenceBuilder<any>
      | SelectQueryBuilderExpression<Record<string, any>>
      | OperandExpressionFactory<DB, TB, any>
- R2 extends
      | string
      | Expression<any>
      | DynamicReferenceBuilder<any>
      | SelectQueryBuilderExpression<Record<string, any>>
      | OperandExpressionFactory<DB, TB, any>
- R3 extends
      | string
      | Expression<any>
      | DynamicReferenceBuilder<any>
      | SelectQueryBuilderExpression<Record<string, any>>
      | OperandExpressionFactory<DB, TB, any>
Parameters
- value1: R1
- value2: R2
- value3: R3
Returns ExpressionWrapper<DB, TB, RefTuple3<DB, TB, R1, R2, R3>>
- Defined in kysely/src/expression/expression-builder.ts:678
refTuple<
    R1 extends
        | string
        | Expression<any>
        | DynamicReferenceBuilder<any>
        | SelectQueryBuilderExpression<Record<string, any>>
        | OperandExpressionFactory<DB, TB, any>,
    R2 extends
        | string
        | Expression<any>
        | DynamicReferenceBuilder<any>
        | SelectQueryBuilderExpression<Record<string, any>>
        | OperandExpressionFactory<DB, TB, any>,
    R3 extends
        | string
        | Expression<any>
        | DynamicReferenceBuilder<any>
        | SelectQueryBuilderExpression<Record<string, any>>
        | OperandExpressionFactory<DB, TB, any>,
    R4 extends
        | string
        | Expression<any>
        | DynamicReferenceBuilder<any>
        | SelectQueryBuilderExpression<Record<string, any>>
        | OperandExpressionFactory<DB, TB, any>,

(
    value1: R1,
    value2: R2,
    value3: R3,
    value4: R4,
): ExpressionWrapper<DB, TB, RefTuple4<DB, TB, R1, R2, R3, R4>>

Type Parameters
- R1 extends
      | string
      | Expression<any>
      | DynamicReferenceBuilder<any>
      | SelectQueryBuilderExpression<Record<string, any>>
      | OperandExpressionFactory<DB, TB, any>
- R2 extends
      | string
      | Expression<any>
      | DynamicReferenceBuilder<any>
      | SelectQueryBuilderExpression<Record<string, any>>
      | OperandExpressionFactory<DB, TB, any>
- R3 extends
      | string
      | Expression<any>
      | DynamicReferenceBuilder<any>
      | SelectQueryBuilderExpression<Record<string, any>>
      | OperandExpressionFactory<DB, TB, any>
- R4 extends
      | string
      | Expression<any>
      | DynamicReferenceBuilder<any>
      | SelectQueryBuilderExpression<Record<string, any>>
      | OperandExpressionFactory<DB, TB, any>
Parameters
- value1: R1
- value2: R2
- value3: R3
- value4: R4
Returns ExpressionWrapper<DB, TB, RefTuple4<DB, TB, R1, R2, R3, R4>>
- Defined in kysely/src/expression/expression-builder.ts:688
refTuple<
    R1 extends
        | string
        | Expression<any>
        | DynamicReferenceBuilder<any>
        | SelectQueryBuilderExpression<Record<string, any>>
        | OperandExpressionFactory<DB, TB, any>,
    R2 extends
        | string
        | Expression<any>
        | DynamicReferenceBuilder<any>
        | SelectQueryBuilderExpression<Record<string, any>>
        | OperandExpressionFactory<DB, TB, any>,
    R3 extends
        | string
        | Expression<any>
        | DynamicReferenceBuilder<any>
        | SelectQueryBuilderExpression<Record<string, any>>
        | OperandExpressionFactory<DB, TB, any>,
    R4 extends
        | string
        | Expression<any>
        | DynamicReferenceBuilder<any>
        | SelectQueryBuilderExpression<Record<string, any>>
        | OperandExpressionFactory<DB, TB, any>,
    R5 extends
        | string
        | Expression<any>
        | DynamicReferenceBuilder<any>
        | SelectQueryBuilderExpression<Record<string, any>>
        | OperandExpressionFactory<DB, TB, any>,

(
    value1: R1,
    value2: R2,
    value3: R3,
    value4: R4,
    value5: R5,
): ExpressionWrapper<DB, TB, RefTuple5<DB, TB, R1, R2, R3, R4, R5>>

Type Parameters
- R1 extends
      | string
      | Expression<any>
      | DynamicReferenceBuilder<any>
      | SelectQueryBuilderExpression<Record<string, any>>
      | OperandExpressionFactory<DB, TB, any>
- R2 extends
      | string
      | Expression<any>
      | DynamicReferenceBuilder<any>
      | SelectQueryBuilderExpression<Record<string, any>>
      | OperandExpressionFactory<DB, TB, any>
- R3 extends
      | string
      | Expression<any>
      | DynamicReferenceBuilder<any>
      | SelectQueryBuilderExpression<Record<string, any>>
      | OperandExpressionFactory<DB, TB, any>
- R4 extends
      | string
      | Expression<any>
      | DynamicReferenceBuilder<any>
      | SelectQueryBuilderExpression<Record<string, any>>
      | OperandExpressionFactory<DB, TB, any>
- R5 extends
      | string
      | Expression<any>
      | DynamicReferenceBuilder<any>
      | SelectQueryBuilderExpression<Record<string, any>>
      | OperandExpressionFactory<DB, TB, any>
Parameters
- value1: R1
- value2: R2
- value3: R3
- value4: R4
- value5: R5
Returns ExpressionWrapper<DB, TB, RefTuple5<DB, TB, R1, R2, R3, R4, R5>>
- Defined in kysely/src/expression/expression-builder.ts:700

selectFrom

selectFrom<
    TE extends
        | string
        | AliasedExpression<any, any>
        | AliasedDynamicTableBuilder<any, any>
        | AliasedExpressionFactory<DB, TB>
        | readonly TableExpression<DB, TB>[],

(
    from: TE,
): SelectFrom<DB, TB, TE>

Creates a subquery.

The query builder returned by this method is typed in a way that you can refer to all tables of the parent query in addition to the subquery’s tables.

This method accepts all the same inputs as QueryCreator.selectFrom.

Examples

This example shows that you can refer to both pet.owner_id and person.id columns from the subquery. This is needed to be able to create correlated subqueries:
```
const result = await db.selectFrom('pet')  
 .select((eb) => [  
 'pet.name',  
 eb.selectFrom('person')  
 .whereRef('person.id', '=', 'pet.owner_id')  
 .select('person.first_name')  
 .as('owner_name')  
 ])  
 .execute()  
  
console.log(result[0]?.owner_name) Copy
```
The generated SQL (PostgreSQL):
```
select "pet"."name", ( select "person"."first_name" from "person" where "person"."id" = "pet"."owner_id" ) as "owner_name" from "pet" Copy
```
You can use a normal query in place of (qb) => qb.selectFrom(...) but in that case Kysely typings wouldn’t allow you to reference pet.owner_id because pet is not joined to that query.

Type Parameters
- TE extends
      | string
      | AliasedExpression<any, any>
      | AliasedDynamicTableBuilder<any, any>
      | AliasedExpressionFactory<DB, TB>
      | readonly TableExpression<DB, TB>[]
Parameters
- from: TE
Returns SelectFrom<DB, TB, TE>
- Defined in kysely/src/expression/expression-builder.ts:296

table

table<T extends string>(table: T): ExpressionWrapper<DB, TB, Selectable<DB[T]>>

Creates a table reference.

Examples


import { sql } from 'kysely'  
import type { Pet } from 'type-editor' // imaginary module  
  
const result = await db.selectFrom('person')  
 .innerJoin('pet', 'pet.owner_id', 'person.id')  
 .select(eb => [  
 'person.id',  
 sql<Pet[]>`jsonb_agg(${eb.table('pet')})`.as('pets')  
 ])  
 .groupBy('person.id')  
 .execute() Copy

The generated SQL (PostgreSQL):


select "person"."id", jsonb_agg("pet") as "pets" from "person" inner join "pet" on "pet"."owner_id" = "person"."id" group by "person"."id" Copy

If you need a column reference, use ref.

Type Parameters

T extends string

Parameters

table: T

Returns ExpressionWrapper<DB, TB, Selectable<DB[T]>>

Defined in kysely/src/expression/expression-builder.ts:550

tuple

tuple<V1, V2>(
value1: V1,
value2: V2,
): ExpressionWrapper<DB, TB, ValTuple2<V1, V2>>

Creates a value tuple expression.

This creates a tuple using values by default. See refTuple if you need to create tuples using column references.

Examples
```
const result = await db.selectFrom('person')  
 .selectAll('person')  
 .where(({ eb, refTuple, tuple }) => eb(  
 refTuple('first_name', 'last_name'),  
 'in',  
 [  
 tuple('Jennifer', 'Aniston'),  
 tuple('Sylvester', 'Stallone')  
 ]  
 ))  
 .execute() Copy
```
The generated SQL (PostgreSQL):
```
select "person".* from "person" where ("first_name", "last_name") in ( ($1, $2), ($3, $4) ) Copy
```
Type Parameters
- V1
- V2
Parameters
- value1: V1
- value2: V2
Returns ExpressionWrapper<DB, TB, ValTuple2<V1, V2>>
- Defined in kysely/src/expression/expression-builder.ts:752
tuple<V1, V2, V3>(
    value1: V1,
    value2: V2,
    value3: V3,
): ExpressionWrapper<DB, TB, ValTuple3<V1, V2, V3>>

Type Parameters
- V1
- V2
- V3
Parameters
- value1: V1
- value2: V2
- value3: V3
Returns ExpressionWrapper<DB, TB, ValTuple3<V1, V2, V3>>
- Defined in kysely/src/expression/expression-builder.ts:757
tuple<V1, V2, V3, V4>(
    value1: V1,
    value2: V2,
    value3: V3,
    value4: V4,
): ExpressionWrapper<DB, TB, ValTuple4<V1, V2, V3, V4>>

Type Parameters
- V1
- V2
- V3
- V4
Parameters
- value1: V1
- value2: V2
- value3: V3
- value4: V4
Returns ExpressionWrapper<DB, TB, ValTuple4<V1, V2, V3, V4>>
- Defined in kysely/src/expression/expression-builder.ts:763
tuple<V1, V2, V3, V4, V5>(
    value1: V1,
    value2: V2,
    value3: V3,
    value4: V4,
    value5: V5,
): ExpressionWrapper<DB, TB, ValTuple5<V1, V2, V3, V4, V5>>

Type Parameters
- V1
- V2
- V3
- V4
- V5
Parameters
- value1: V1
- value2: V2
- value3: V3
- value4: V4
- value5: V5
Returns ExpressionWrapper<DB, TB, ValTuple5<V1, V2, V3, V4, V5>>
- Defined in kysely/src/expression/expression-builder.ts:770

unary

unary<
    RE extends
        | string
        | Expression<any>
        | DynamicReferenceBuilder<any>
        | SelectQueryBuilderExpression<Record<string, any>>
        | OperandExpressionFactory<DB, TB, any>,

(
    op: ”-” | “exists” | “not exists” | “not”,
    expr: RE,
): ExpressionWrapper<DB, TB, ExtractTypeFromReferenceExpression<DB, TB, RE>>

Creates an unary expression.

This function returns an Expression and can be used pretty much anywhere. See the examples for a couple of possible use cases.

Type Parameters
- RE extends
      | string
      | Expression<any>
      | DynamicReferenceBuilder<any>
      | SelectQueryBuilderExpression<Record<string, any>>
      | OperandExpressionFactory<DB, TB, any>
Parameters
- op: ”-” | “exists” | “not exists” | “not”
- expr: RE
Returns ExpressionWrapper<DB, TB, ExtractTypeFromReferenceExpression<DB, TB, RE>>

See

not, exists and neg.

Examples
```
const result = await db.selectFrom('person')  
 .select((eb) => [  
 'first_name',  
 eb.unary('-', 'age').as('negative_age')  
 ])  
 .execute() Copy
```
The generated SQL (PostgreSQL):
```
select "first_name", -"age" from "person" Copy
```
- Defined in kysely/src/expression/expression-builder.ts:829

val

val<VE>(
value: VE,
): ExpressionWrapper<DB, TB, ExtractTypeFromValueExpression<VE>>

Returns a value expression.

This can be used to pass in a value where a reference is taken by default.

This function returns an Expression and can be used pretty much anywhere.

Examples

Binary expressions take a reference by default as the first argument. val could be used to pass in a value instead:
```
const result = await db.selectFrom('person')  
 .selectAll()  
 .where((eb) => eb(  
 eb.val('cat'),  
 '=',  
 eb.fn.any(  
 eb.selectFrom('pet')  
 .select('species')  
 .whereRef('owner_id', '=', 'person.id')  
 )  
 ))  
 .execute() Copy
```
The generated SQL (PostgreSQL):
```
select * from "person" where $1 = any( select "species" from "pet" where "owner_id" = "person"."id" ) Copy
```
Type Parameters
- VE
Parameters
- value: VE
Returns ExpressionWrapper<DB, TB, ExtractTypeFromValueExpression<VE>>
- Defined in kysely/src/expression/expression-builder.ts:593

withSchema

withSchema(schema: string): ExpressionBuilder<DB, TB>

See QueryCreator.withSchema

Parameters
- schema: string
Returns ExpressionBuilder<DB, TB>

Deprecated

Will be removed in kysely 0.25.0.
- Defined in kysely/src/expression/expression-builder.ts:1153

Settings

Member Visibility

Protected
Inherited
External

ThemeOSLightDark

Interface ExpressionBuilder

Type Parameters

Examples

Type Parameters

Parameters

Index

Accessors

Methods

Accessors

eb

Examples

Returns ExpressionBuilder<DB, TB>

fn

Returns FunctionModule<DB, TB>

Methods

and

Examples

Type Parameters

Parameters

Returns ExpressionWrapper<DB, TB, SqlBool>

Type Parameters

Parameters

Returns ExpressionWrapper<DB, TB, SqlBool>

between

Examples

Type Parameters

Parameters

Returns ExpressionWrapper<DB, TB, SqlBool>

betweenSymmetric

Examples

Type Parameters

Parameters

Returns ExpressionWrapper<DB, TB, SqlBool>

case

Examples

Returns CaseBuilder<DB, TB>

Type Parameters

Parameters

Returns CaseBuilder<DB, TB, ExtractTypeFromReferenceExpression<DB, TB, C>>

Type Parameters

Parameters

Returns CaseBuilder<DB, TB, ExtractTypeFromValueExpression<E>>

cast

Examples

Type Parameters

Parameters

Returns ExpressionWrapper<DB, TB, T>

exists

Type Parameters

Parameters

Returns ExpressionWrapper<DB, TB, SqlBool>

See

jsonPath

Examples

Type Parameters

Returns IsNever<$> extends true ? KyselyTypeError< “You must provide a column reference as this method’s $ generic”, > : JSONPathBuilder< ExtractTypeFromReferenceExpression<DB, TB, $>, ExtractTypeFromReferenceExpression<DB, TB, $>, >

lit

Examples

Type Parameters

Parameters

Returns ExpressionWrapper<DB, TB, VE>

neg

Type Parameters

Parameters

Returns ExpressionWrapper<DB, TB, ExtractTypeFromReferenceExpression<DB, TB, RE>>

See

not

Type Parameters

Parameters

Returns ExpressionWrapper<DB, TB, ExtractTypeFromReferenceExpression<DB, TB, RE>>

See

or

Examples

Type Parameters

Parameters

Returns ExpressionWrapper<DB, TB, SqlBool>

Type Parameters

Parameters

Returns ExpressionWrapper<DB, TB, SqlBool>

parens