Class ExpressionWrapper<DB, TB, T>

Change the output type of the expression.

This method call doesn't change the SQL in any way. This methods simply returns a copy of this ExpressionWrapper with a new output type.

Omit null from the expression's type.

This function can be useful in cases where you know an expression can't be null, but Kysely is unable to infer it.

This method call doesn't change the SQL in any way. This methods simply returns a copy of this with a new output type.

Combines this and another expression using AND.

Also see and

Examples

db.selectFrom('person')
  .selectAll()
  .where(eb => eb('first_name', '=', 'Jennifer')
    .and('last_name', '=', 'Aniston')
    .and('age', '>', 40)
  )
Copy

The generated SQL (PostgreSQL):

select *
from "person"
where (
  "first_name" = $1
  and "last_name" = $2
  and "age" > $3
)
Copy

You can also pass any expression as the only argument to this method:

db.selectFrom('person')
  .selectAll()
  .where(eb => eb('first_name', '=', 'Jennifer')
    .and(eb('first_name', '=', 'Sylvester').or('last_name', '=', 'Stallone'))
    .and(eb.exists(
      eb.selectFrom('pet')
        .select('id')
        .whereRef('pet.owner_id', '=', 'person.id')
    )
  )
Copy

The generated SQL (PostgreSQL):

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

Returns an aliased version of the expression.

In addition to slapping as "the_alias" to the end of the SQL, this method also provides strict typing:

const result = await db
  .selectFrom('person')
  .select((eb) =>
    eb('first_name', '=', 'Jennifer').as('is_jennifer')
  )
  .executeTakeFirstOrThrow()

// `is_jennifer: SqlBool` field exists in the result type.
console.log(result.is_jennifer)
Copy

The generated SQL (PostgreSQL):

select "first_name" = $1 as "is_jennifer"
from "person"
Copy

Combines this and another expression using OR.

Also see or

Examples

db.selectFrom('person')
  .selectAll()
  .where(eb => eb('first_name', '=', 'Jennifer')
    .or('first_name', '=', 'Arnold')
    .or('first_name', '=', 'Sylvester')
  )
Copy

The generated SQL (PostgreSQL):

select *
from "person"
where (
  "first_name" = $1
  or "first_name" = $2
  or "first_name" = $3
)
Copy

You can also pass any expression as the only argument to this method:

db.selectFrom('person')
  .selectAll()
  .where(eb => eb('first_name', '=', 'Jennifer')
    .or(eb('first_name', '=', 'Sylvester').and('last_name', '=', 'Stallone'))
    .or(eb.exists(
      eb.selectFrom('pet')
        .select('id')
        .whereRef('pet.owner_id', '=', 'person.id')
    )
  )
Copy

The generated SQL (PostgreSQL):

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

Creates the OperationNode that describes how to compile this expression into SQL.

If you are creating a custom expression, it's often easiest to use the sql template tag to build the node:

class SomeExpression<T> implements Expression<T> {
  toOperationNode(): OperationNode {
    return sql`some sql here`.toOperationNode()
  }
}
Copy