ExpressionWrapper
§Implements
§Constructors
§Properties
All expressions need to have this getter for complicated type-related reasons.
Simply add this getter for your expression and always return undefined
from it:
class SomeExpression<T> implements Expression<T> {
get expressionType(): T | undefined {
return undefined
}
}
The getter is needed to make the expression assignable to another expression only
if the types T
are assignable. Without this property (or some other property
that references T
), you could assing Expression<string>
to Expression<number>
.
§Methods
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 ExpressionBuilder.and
Examples
db.selectFrom('person')
.selectAll()
.where(eb => eb('first_name', '=', 'Jennifer')
.and('last_name', '=', 'Aniston')
.and('age', '>', 40)
)
The generated SQL (PostgreSQL):
select *
from "person"
where (
"first_name" = $1
and "last_name" = $2
and "age" > $3
)
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')
)
)
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"
)
)
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)
The generated SQL (PostgreSQL):
select "first_name" = $1 as "is_jennifer"
from "person"
Returns an aliased version of the expression.
In addition to slapping as "the_alias"
at the end of the expression,
this method also provides strict typing:
const result = await db
.selectFrom('person')
.select((eb) =>
// `eb.fn<string>` returns an AliasableExpression<string>
eb.fn<string>('concat', ['first_name' eb.val(' '), 'last_name']).as('full_name')
)
.executeTakeFirstOrThrow()
// `full_name: string` field exists in the result type.
console.log(result.full_name)
The generated SQL (PostgreSQL):
select
concat("first_name", $1, "last_name") as "full_name"
from
"person"
You can also pass in a raw SQL snippet (or any expression) but in that case you must provide the alias as the only type argument:
const values = sql<{ a: number, b: string }>`(values (1, 'foo'))`
// The alias is `t(a, b)` which specifies the column names
// in addition to the table name. We must tell kysely that
// columns of the table can be referenced through `t`
// by providing an explicit type argument.
const aliasedValues = values.as<'t'>(sql`t(a, b)`)
await db
.insertInto('person')
.columns(['first_name', 'last_name'])
.expression(
db.selectFrom(aliasedValues).select(['t.a', 't.b'])
)
The generated SQL (PostgreSQL):
insert into "person" ("first_name", "last_name")
from (values (1, 'foo')) as t(a, b)
select "t"."a", "t"."b"
Combines this
and another expression using OR
.
Also see ExpressionBuilder.or
Examples
db.selectFrom('person')
.selectAll()
.where(eb => eb('first_name', '=', 'Jennifer')
.or('first_name', '=', 'Arnold')
.or('first_name', '=', 'Sylvester')
)
The generated SQL (PostgreSQL):
select *
from "person"
where (
"first_name" = $1
or "first_name" = $2
or "first_name" = $3
)
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')
)
)
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"
)
)
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()
}
}