Skip to Content
Api ReferenceInterfacesAliasableExpression

Last Updated: 3/10/2026

kysely

  • AliasableExpression

Interface AliasableExpression

An expression with an as method.

interface AliasableExpression<T> {
    get expressionType(): undefined | T;
    as<A extends string>(alias: A): AliasedExpression<T, A>;
    as<A extends string>(alias: Expression<any>): AliasedExpression<T, A>;
    toOperationNode(): OperationNode;
}

Type Parameters

  • T

Hierarchy (View Summary)

Implemented by

Index

Accessors

expressionType

Methods

as toOperationNode

Accessors

expressionType

  • get expressionType(): undefined | T

    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:

    Examples

    import { type  Expression, type  OperationNode, sql } from  'kysely' class  SomeExpression< T> implements  Expression< T> { get  expressionType(): T  |  undefined { return  undefined }  toOperationNode(): OperationNode { return  sql `some sql here`. toOperationNode() }}

    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 to Expression.

    Returns undefined | T

Methods

as

  • as<A extends string>(alias: A): AliasedExpression<T, A>

    Returns an aliased version of the expression.

    Examples

    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` returns an AliasableExpression  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:

    import { sql } from  'kysely' 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']) ) . execute()

    The generated SQL (PostgreSQL):

    insert into "person" ("first_name", "last_name") from (values (1, 'foo')) as t(a, b) select "t"."a", "t"."b"

    Type Parameters

    • A extends string

    Parameters

    • alias: A

    Returns AliasedExpression<T, A>

  • as<A extends string>(alias: Expression<any>): AliasedExpression<T, A>

    Type Parameters

    • A extends string

    Parameters

    Returns AliasedExpression<T, A>

toOperationNode

  • toOperationNode(): OperationNode

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

    Examples

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

    import { type  Expression, type  OperationNode, sql } from  'kysely' class  SomeExpression< T> implements  Expression< T> { get  expressionType(): T  | undefined { return  undefined }  toOperationNode(): OperationNode { return  sql `some sql here`. toOperationNode() }}

    Returns OperationNode

Settings

Member Visibility

On This Page

Accessors

expressionType

Methods

as

toOperationNode

KyselyPluginReturningInterface