kysely 0.26.3 → 0.27.0

package/dist/esm/query-builder/on-conflict-builder.js

@@ -3,7 +3,7 @@ import { ColumnNode } from '../operation-node/column-node.js';
 import { IdentifierNode } from '../operation-node/identifier-node.js';
 import { OnConflictNode } from '../operation-node/on-conflict-node.js';
 import { parseValueBinaryOperationOrExpression, parseReferentialBinaryOperation, } from '../parser/binary-operation-parser.js';
-import { parseUpdateExpression, } from '../parser/update-set-parser.js';
+import { parseUpdateObjectExpression, } from '../parser/update-set-parser.js';
 import { freeze } from '../util/object-utils.js';
 import { preventAwait } from '../util/prevent-await.js';
 export class OnConflictBuilder {
@@ -81,11 +81,6 @@ export class OnConflictBuilder {
             onConflictNode: OnConflictNode.cloneWithIndexWhere(this.#props.onConflictNode, parseValueBinaryOperationOrExpression(args)),
         });
     }
-    /**
-     * Specify an index predicate for the index target.
-     *
-     * See {@link WhereInterface.whereRef} for more info.
-     */
     whereRef(lhs, op, rhs) {
         return new OnConflictBuilder({
             ...this.#props,
@@ -173,7 +168,7 @@ export class OnConflictBuilder {
         return new OnConflictUpdateBuilder({
             ...this.#props,
             onConflictNode: OnConflictNode.cloneWith(this.#props.onConflictNode, {
-                updates: parseUpdateExpression(update),
+                updates: parseUpdateObjectExpression(update),
             }),
         });
     }

package/dist/esm/query-builder/over-builder.d.ts

@@ -28,7 +28,7 @@ export declare class OverBuilder<DB, TB extends keyof DB> implements OperationNo
      * from "person"
      * ```
      */
-    orderBy(orderBy: StringReference<DB, TB> | DynamicReferenceBuilder<any>, direction?: OrderByDirectionExpression): OverBuilder<DB, TB>;
+    orderBy<OE extends StringReference<DB, TB> | DynamicReferenceBuilder<any>>(orderBy: OE, direction?: OrderByDirectionExpression): OverBuilder<DB, TB>;
     /**
      * Adds partition by clause item/s inside the over function.
      *
@@ -51,7 +51,7 @@ export declare class OverBuilder<DB, TB extends keyof DB> implements OperationNo
      * ```
      */
     partitionBy(partitionBy: ReadonlyArray<PartitionByExpression<DB, TB>>): OverBuilder<DB, TB>;
-    partitionBy(partitionBy: PartitionByExpression<DB, TB>): OverBuilder<DB, TB>;
+    partitionBy<PE extends PartitionByExpression<DB, TB>>(partitionBy: PE): OverBuilder<DB, TB>;
     /**
      * Simply calls the provided function passing `this` as the only argument. `$call` returns
      * what the provided function returns.

package/dist/esm/query-builder/select-query-builder.d.ts

@@ -325,8 +325,8 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
      *   .execute()
      * ```
      */
-    where<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): SelectQueryBuilder<DB, TB, O>;
-    where(expression: ExpressionOrFactory<DB, TB, SqlBool>): SelectQueryBuilder<DB, TB, O>;
+    where<RE extends ReferenceExpression<DB, TB>, VE extends OperandValueExpressionOrList<DB, TB, RE>>(lhs: RE, op: ComparisonOperatorExpression, rhs: VE): SelectQueryBuilder<DB, TB, O>;
+    where<E extends ExpressionOrFactory<DB, TB, SqlBool>>(expression: E): SelectQueryBuilder<DB, TB, O>;
     /**
      * Adds a `where` clause where both sides of the operator are references
      * to columns.
@@ -378,18 +378,18 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
      * ) as "pet_name"
      * from "person"
      */
-    whereRef(lhs: ReferenceExpression<DB, TB>, op: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): SelectQueryBuilder<DB, TB, O>;
+    whereRef<LRE extends ReferenceExpression<DB, TB>, RRE extends ReferenceExpression<DB, TB>>(lhs: LRE, op: ComparisonOperatorExpression, rhs: RRE): SelectQueryBuilder<DB, TB, O>;
     /**
      * Just like {@link WhereInterface.where | where} but adds a `having` statement
      * instead of a `where` statement.
      */
-    having<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): SelectQueryBuilder<DB, TB, O>;
-    having(expression: ExpressionOrFactory<DB, TB, SqlBool>): SelectQueryBuilder<DB, TB, O>;
+    having<RE extends ReferenceExpression<DB, TB>, VE extends OperandValueExpressionOrList<DB, TB, RE>>(lhs: RE, op: ComparisonOperatorExpression, rhs: VE): SelectQueryBuilder<DB, TB, O>;
+    having<E extends ExpressionOrFactory<DB, TB, SqlBool>>(expression: E): SelectQueryBuilder<DB, TB, O>;
     /**
      * Just like {@link WhereInterface.whereRef | whereRef} but adds a `having` statement
      * instead of a `where` statement.
      */
-    havingRef(lhs: ReferenceExpression<DB, TB>, op: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): SelectQueryBuilder<DB, TB, O>;
+    havingRef<LRE extends ReferenceExpression<DB, TB>, RRE extends ReferenceExpression<DB, TB>>(lhs: LRE, op: ComparisonOperatorExpression, rhs: RRE): SelectQueryBuilder<DB, TB, O>;
     /**
      * Adds a select statement to the query.
      *
@@ -468,14 +468,14 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
      *
      * <!-- siteExample("select", "Aliases", 40) -->
      *
-     * You can provide an alias for the selections by appending `as the_alias` to the selection.
+     * You can give an alias for selections and tables by appending `as the_alias` to the name:
      *
      * ```ts
      * const persons = await db
-     *   .selectFrom('person')
+     *   .selectFrom('person as p')
      *   .select([
      *     'first_name as fn',
-     *     'person.last_name as ln'
+     *     'p.last_name as ln'
      *   ])
      *   .execute()
      * ```
@@ -485,8 +485,8 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
      * ```sql
      * select
      *   "first_name" as "fn",
-     *   "person"."last_name" as "ln"
-     * from "person"
+     *   "p"."last_name" as "ln"
+     * from "person" as "p"
      * ```
      *
      * <!-- siteExample("select", "Complex selections", 50) -->
@@ -1035,9 +1035,9 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
      * order by "fn" asc
      * ```
      */
-    orderBy(orderBy: UndirectedOrderByExpression<DB, TB, O>, direction?: OrderByDirectionExpression): SelectQueryBuilder<DB, TB, O>;
-    orderBy(ref: DirectedOrderByStringReference<DB, TB, O>): SelectQueryBuilder<DB, TB, O>;
-    orderBy(refs: ReadonlyArray<OrderByExpression<DB, TB, O>>): SelectQueryBuilder<DB, TB, O>;
+    orderBy<OE extends UndirectedOrderByExpression<DB, TB, O>>(orderBy: OE, direction?: OrderByDirectionExpression): SelectQueryBuilder<DB, TB, O>;
+    orderBy<OE extends DirectedOrderByStringReference<DB, TB, O>>(ref: OE): SelectQueryBuilder<DB, TB, O>;
+    orderBy<OE extends OrderByExpression<DB, TB, O>>(refs: ReadonlyArray<OE>): SelectQueryBuilder<DB, TB, O>;
     /**
      * Adds a `group by` clause to the query.
      *
@@ -1136,7 +1136,7 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
      * group by "first_name"
      * ```
      */
-    groupBy(groupBy: GroupByArg<DB, TB, O>): SelectQueryBuilder<DB, TB, O>;
+    groupBy<GE extends GroupByArg<DB, TB, O>>(groupBy: GE): SelectQueryBuilder<DB, TB, O>;
     /**
      * Adds a limit clause to the query.
      *
@@ -1204,7 +1204,7 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
      *   .orderBy('name')
      * ```
      */
-    union(expression: SetOperandExpression<DB, O>): SelectQueryBuilder<DB, TB, O>;
+    union<E extends SetOperandExpression<DB, O>>(expression: E): SelectQueryBuilder<DB, TB, O>;
     /**
      * Combines another select query or raw expression to this query using `union all`.
      *
@@ -1231,7 +1231,7 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
      *   .orderBy('name')
      * ```
      */
-    unionAll(expression: SetOperandExpression<DB, O>): SelectQueryBuilder<DB, TB, O>;
+    unionAll<E extends SetOperandExpression<DB, O>>(expression: E): SelectQueryBuilder<DB, TB, O>;
     /**
      * Combines another select query or raw expression to this query using `intersect`.
      *
@@ -1258,7 +1258,7 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
      *   .orderBy('name')
      * ```
      */
-    intersect(expression: SetOperandExpression<DB, O>): SelectQueryBuilder<DB, TB, O>;
+    intersect<E extends SetOperandExpression<DB, O>>(expression: E): SelectQueryBuilder<DB, TB, O>;
     /**
      * Combines another select query or raw expression to this query using `intersect all`.
      *
@@ -1285,7 +1285,7 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
      *   .orderBy('name')
      * ```
      */
-    intersectAll(expression: SetOperandExpression<DB, O>): SelectQueryBuilder<DB, TB, O>;
+    intersectAll<E extends SetOperandExpression<DB, O>>(expression: E): SelectQueryBuilder<DB, TB, O>;
     /**
      * Combines another select query or raw expression to this query using `except`.
      *
@@ -1312,7 +1312,7 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
      *   .orderBy('name')
      * ```
      */
-    except(expression: SetOperandExpression<DB, O>): SelectQueryBuilder<DB, TB, O>;
+    except<E extends SetOperandExpression<DB, O>>(expression: E): SelectQueryBuilder<DB, TB, O>;
     /**
      * Combines another select query or raw expression to this query using `except all`.
      *
@@ -1339,7 +1339,7 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
      *   .orderBy('name')
      * ```
      */
-    exceptAll(expression: SetOperandExpression<DB, O>): SelectQueryBuilder<DB, TB, O>;
+    exceptAll<E extends SetOperandExpression<DB, O>>(expression: E): SelectQueryBuilder<DB, TB, O>;
     /**
      * Gives an alias for the query. This method is only useful for sub queries.
      *
@@ -1545,7 +1545,7 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
      *   )
      * ```
      */
-    $if<O2>(condition: boolean, func: (qb: this) => SelectQueryBuilder<any, any, O & O2>): SelectQueryBuilder<DB, TB, O & Partial<O2>>;
+    $if<O2>(condition: boolean, func: (qb: this) => SelectQueryBuilder<any, any, O & O2>): SelectQueryBuilder<DB, TB, O & Partial<Omit<O2, keyof O>>>;
     /**
      * Change the output type of the query.
      *
@@ -1640,6 +1640,22 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
      *
      * functionThatExpectsPersonWithNonNullValue(person)
      * ```
+     *
+     * Giving the explicit narrowed type (`string` in the example above) works fine for
+     * simple types. If the type is complex, for example a JSON column or a subquery,
+     * you can use the special `NotNull` type to make the column not null.
+     *
+     * ```ts
+     * import { NotNull } from 'kysely'
+     *
+     * const person = await db.selectFrom('person')
+     *   .where('nullable_column', 'is not', null)
+     *   .selectAll()
+     *   .$narrowType<{ nullable_column: NotNull }>()
+     *   .executeTakeFirstOrThrow()
+     *
+     * functionThatExpectsPersonWithNonNullValue(person)
+     * ```
      */
     $narrowType<T>(): SelectQueryBuilder<DB, TB, NarrowPartial<O, T>>;
     /**

package/dist/esm/query-builder/update-query-builder.d.ts

@@ -8,7 +8,7 @@ import { ReferenceExpression } from '../parser/reference-parser.js';
 import { QueryNode } from '../operation-node/query-node.js';
 import { DrainOuterGeneric, NarrowPartial, Nullable, ShallowRecord, SimplifyResult, SimplifySingleResult, SqlBool } from '../util/type-utils.js';
 import { UpdateQueryNode } from '../operation-node/update-query-node.js';
-import { UpdateObject, UpdateObjectFactory } from '../parser/update-set-parser.js';
+import { UpdateObject, UpdateObjectFactory, ExtractUpdateTypeFromReferenceExpression } from '../parser/update-set-parser.js';
 import { Compilable } from '../util/compilable.js';
 import { QueryExecutor } from '../query-executor/query-executor.js';
 import { QueryId } from '../util/query-id.js';
@@ -24,6 +24,7 @@ import { ComparisonOperatorExpression, OperandValueExpressionOrList } from '../p
 import { KyselyTypeError } from '../util/type-error.js';
 import { Streamable } from '../util/streamable.js';
 import { ExpressionOrFactory } from '../parser/expression-parser.js';
+import { ValueExpression } from '../parser/value-parser.js';
 export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyof DB, O> implements WhereInterface<DB, TB>, ReturningInterface<DB, TB, O>, OperationNodeSource, Compilable<O>, Explainable, Streamable<O> {
     #private;
     constructor(props: UpdateQueryBuilderProps);
@@ -326,8 +327,8 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      *   .execute()
      * ```
      */
-    where<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): UpdateQueryBuilder<DB, UT, TB, O>;
-    where(expression: ExpressionOrFactory<DB, TB, SqlBool>): UpdateQueryBuilder<DB, UT, TB, O>;
+    where<RE extends ReferenceExpression<DB, TB>, VE extends OperandValueExpressionOrList<DB, TB, RE>>(lhs: RE, op: ComparisonOperatorExpression, rhs: VE): UpdateQueryBuilder<DB, UT, TB, O>;
+    where<E extends ExpressionOrFactory<DB, TB, SqlBool>>(expression: E): UpdateQueryBuilder<DB, UT, TB, O>;
     /**
      * Adds a `where` clause where both sides of the operator are references
      * to columns.
@@ -379,7 +380,7 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      * ) as "pet_name"
      * from "person"
      */
-    whereRef(lhs: ReferenceExpression<DB, TB>, op: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): UpdateQueryBuilder<DB, UT, TB, O>;
+    whereRef<LRE extends ReferenceExpression<DB, TB>, RRE extends ReferenceExpression<DB, TB>>(lhs: LRE, op: ComparisonOperatorExpression, rhs: RRE): UpdateQueryBuilder<DB, UT, TB, O>;
     /**
      * Clears all where expressions from the query.
      *
@@ -625,6 +626,20 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      *   "id" = $4
      * ```
      *
+     * If you provide two arguments the first one is interpreted as the column
+     * (or other target) and the second as the value:
+     *
+     * ```ts
+     * const result = await db
+     *   .updateTable('person')
+     *   .set('first_name', 'Foo')
+     *   // As always, both arguments can be arbitrary expressions or
+     *   // callbacks that give you access to an expression builder:
+     *   .set(sql`address['postalCode']`, (eb) => eb.val('61710))
+     *   .where('id', '=', '1')
+     *   .executeTakeFirst()
+     * ```
+     *
      * On PostgreSQL you can chain `returning` to the query to get
      * the updated rows' columns (or any other expression) as the
      * return value:
@@ -682,6 +697,7 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      */
     set(update: UpdateObject<DB, TB, UT>): UpdateQueryBuilder<DB, UT, TB, O>;
     set(update: UpdateObjectFactory<DB, TB, UT>): UpdateQueryBuilder<DB, UT, TB, O>;
+    set<RE extends ReferenceExpression<DB, UT>>(key: RE, value: ValueExpression<DB, TB, ExtractUpdateTypeFromReferenceExpression<DB, UT, RE>>): UpdateQueryBuilder<DB, UT, TB, O>;
     /**
      * Allows you to return data from modified rows.
      *

package/dist/esm/query-builder/update-query-builder.js

@@ -4,7 +4,7 @@ import { parseTableExpressionOrList, } from '../parser/table-parser.js';
 import { parseSelectArg, parseSelectAll, } from '../parser/select-parser.js';
 import { QueryNode } from '../operation-node/query-node.js';
 import { UpdateQueryNode } from '../operation-node/update-query-node.js';
-import { parseUpdateExpression, } from '../parser/update-set-parser.js';
+import { parseUpdate, } from '../parser/update-set-parser.js';
 import { preventAwait } from '../util/prevent-await.js';
 import { freeze } from '../util/object-utils.js';
 import { UpdateResult } from './update-result.js';
@@ -63,10 +63,10 @@ export class UpdateQueryBuilder {
             queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoin('FullJoin', args)),
         });
     }
-    set(update) {
+    set(...args) {
         return new UpdateQueryBuilder({
             ...this.#props,
-            queryNode: UpdateQueryNode.cloneWithUpdates(this.#props.queryNode, parseUpdateExpression(update)),
+            queryNode: UpdateQueryNode.cloneWithUpdates(this.#props.queryNode, parseUpdate(...args)),
         });
     }
     returning(selection) {

package/dist/esm/query-builder/where-interface.d.ts

@@ -302,8 +302,8 @@ export interface WhereInterface<DB, TB extends keyof DB> {
      *   .execute()
      * ```
      */
-    where<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): WhereInterface<DB, TB>;
-    where(expression: ExpressionOrFactory<DB, TB, SqlBool>): WhereInterface<DB, TB>;
+    where<RE extends ReferenceExpression<DB, TB>, VE extends OperandValueExpressionOrList<DB, TB, RE>>(lhs: RE, op: ComparisonOperatorExpression, rhs: VE): WhereInterface<DB, TB>;
+    where<E extends ExpressionOrFactory<DB, TB, SqlBool>>(expression: E): WhereInterface<DB, TB>;
     /**
      * Adds a `where` clause where both sides of the operator are references
      * to columns.
@@ -355,7 +355,7 @@ export interface WhereInterface<DB, TB extends keyof DB> {
      * ) as "pet_name"
      * from "person"
      */
-    whereRef(lhs: ReferenceExpression<DB, TB>, op: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): WhereInterface<DB, TB>;
+    whereRef<LRE extends ReferenceExpression<DB, TB>, RRE extends ReferenceExpression<DB, TB>>(lhs: LRE, op: ComparisonOperatorExpression, rhs: RRE): WhereInterface<DB, TB>;
     /**
      * Clears all where expressions from the query.
      *

package/dist/esm/query-compiler/default-query-compiler.d.ts

@@ -48,7 +48,7 @@ import { RootOperationNode, QueryCompiler } from './query-compiler.js';
 import { HavingNode } from '../operation-node/having-node.js';
 import { CreateSchemaNode } from '../operation-node/create-schema-node.js';
 import { DropSchemaNode } from '../operation-node/drop-schema-node.js';
-import { AlterTableNode } from '../operation-node/alter-table-node.js';
+import { AlterTableColumnAlterationNode, AlterTableNode } from '../operation-node/alter-table-node.js';
 import { DropColumnNode } from '../operation-node/drop-column-node.js';
 import { RenameColumnNode } from '../operation-node/rename-column-node.js';
 import { AlterColumnNode } from '../operation-node/alter-column-node.js';
@@ -88,6 +88,7 @@ import { JSONPathNode } from '../operation-node/json-path-node.js';
 import { JSONPathLegNode } from '../operation-node/json-path-leg-node.js';
 import { JSONOperatorChainNode } from '../operation-node/json-operator-chain-node.js';
 import { TupleNode } from '../operation-node/tuple-node.js';
+import { AddIndexNode } from '../operation-node/add-index-node.js';
 export declare class DefaultQueryCompiler extends OperationNodeVisitor implements QueryCompiler {
     #private;
     protected get numParameters(): number;
@@ -184,6 +185,7 @@ export declare class DefaultQueryCompiler extends OperationNodeVisitor implement
     protected visitJSONPath(node: JSONPathNode): void;
     protected visitJSONPathLeg(node: JSONPathLegNode): void;
     protected visitJSONOperatorChain(node: JSONOperatorChainNode): void;
+    protected visitAddIndex(node: AddIndexNode): void;
     protected append(str: string): void;
     protected appendValue(parameter: unknown): void;
     protected getLeftIdentifierWrapper(): string;
@@ -197,4 +199,10 @@ export declare class DefaultQueryCompiler extends OperationNodeVisitor implement
     protected addParameter(parameter: unknown): void;
     protected appendImmediateValue(value: unknown): void;
     protected sortSelectModifiers(arr: SelectModifierNode[]): ReadonlyArray<SelectModifierNode>;
+    protected compileColumnAlterations(columnAlterations: readonly AlterTableColumnAlterationNode[]): void;
+    /**
+     * controls whether the dialect adds a "type" keyword before a column's new data
+     * type in an ALTER TABLE statement.
+     */
+    protected announcesNewColumnDataType(): boolean;
 }

package/dist/esm/query-compiler/default-query-compiler.js

@@ -1,4 +1,5 @@
 /// <reference types="./default-query-compiler.d.ts" />
+import { CreateTableNode } from '../operation-node/create-table-node.js';
 import { InsertQueryNode } from '../operation-node/insert-query-node.js';
 import { OperationNodeVisitor } from '../operation-node/operation-node-visitor.js';
 import { OperatorNode } from '../operation-node/operator-node.js';
@@ -30,6 +31,7 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
         const wrapInParens = this.parentNode !== undefined &&
             !ParensNode.is(this.parentNode) &&
             !InsertQueryNode.is(this.parentNode) &&
+            !CreateTableNode.is(this.parentNode) &&
             !CreateViewNode.is(this.parentNode) &&
             !SetOperationNode.is(this.parentNode);
         if (this.parentNode === undefined && node.explain) {
@@ -346,16 +348,22 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.append('if not exists ');
         }
         this.visitNode(node.table);
-        this.append(' (');
-        this.compileList([...node.columns, ...(node.constraints ?? [])]);
-        this.append(')');
-        if (node.onCommit) {
-            this.append(' on commit ');
-            this.append(node.onCommit);
+        if (node.selectQuery) {
+            this.append(' as ');
+            this.visitNode(node.selectQuery);
         }
-        if (node.endModifiers && node.endModifiers.length > 0) {
-            this.append(' ');
-            this.compileList(node.endModifiers, ' ');
+        else {
+            this.append(' (');
+            this.compileList([...node.columns, ...(node.constraints ?? [])]);
+            this.append(')');
+            if (node.onCommit) {
+                this.append(' on commit ');
+                this.append(node.onCommit);
+            }
+            if (node.endModifiers && node.endModifiers.length > 0) {
+                this.append(' ');
+                this.compileList(node.endModifiers, ' ');
+            }
         }
     }
     visitColumnDefinition(node) {
@@ -383,6 +391,9 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
         if (node.unique) {
             this.append(' unique');
         }
+        if (node.nullsNotDistinct) {
+            this.append(' nulls not distinct');
+        }
         if (node.primaryKey) {
             this.append(' primary key');
         }
@@ -563,6 +574,9 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.compileList(node.columns);
             this.append(')');
         }
+        if (node.nullsNotDistinct) {
+            this.append(' nulls not distinct');
+        }
         if (node.where) {
             this.append(' ');
             this.visitNode(node.where);
@@ -615,7 +629,11 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.visitNode(node.name);
             this.append(' ');
         }
-        this.append('unique (');
+        this.append('unique');
+        if (node.nullsNotDistinct) {
+            this.append(' nulls not distinct');
+        }
+        this.append(' (');
         this.compileList(node.columns);
         this.append(')');
     }
@@ -696,7 +714,13 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.visitNode(node.dropConstraint);
         }
         if (node.columnAlterations) {
-            this.compileList(node.columnAlterations);
+            this.compileColumnAlterations(node.columnAlterations);
+        }
+        if (node.addIndex) {
+            this.visitNode(node.addIndex);
+        }
+        if (node.dropIndex) {
+            this.visitNode(node.dropIndex);
         }
     }
     visitAddColumn(node) {
@@ -718,7 +742,9 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
         this.visitNode(node.column);
         this.append(' ');
         if (node.dataType) {
-            this.append('type ');
+            if (this.announcesNewColumnDataType()) {
+                this.append('type ');
+            }
             this.visitNode(node.dataType);
             if (node.dataTypeExpression) {
                 this.append('using ');
@@ -1004,6 +1030,23 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.visitNode(node.values[i]);
         }
     }
+    visitAddIndex(node) {
+        this.append('add ');
+        if (node.unique) {
+            this.append('unique ');
+        }
+        this.append('index ');
+        this.visitNode(node.name);
+        if (node.columns) {
+            this.append(' (');
+            this.compileList(node.columns);
+            this.append(')');
+        }
+        if (node.using) {
+            this.append(' using ');
+            this.visitNode(node.using);
+        }
+    }
     append(str) {
         this.#sql += str;
     }
@@ -1077,6 +1120,16 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             : 1);
         return freeze(arr);
     }
+    compileColumnAlterations(columnAlterations) {
+        this.compileList(columnAlterations);
+    }
+    /**
+     * controls whether the dialect adds a "type" keyword before a column's new data
+     * type in an ALTER TABLE statement.
+     */
+    announcesNewColumnDataType() {
+        return true;
+    }
 }
 const SELECT_MODIFIER_SQL = freeze({
     ForKeyShare: 'for key share',

package/dist/esm/schema/alter-table-add-index-builder.d.ts

@@ -0,0 +1,104 @@
+import { Expression } from '../expression/expression.js';
+import { AlterTableNode } from '../operation-node/alter-table-node.js';
+import { IndexType } from '../operation-node/create-index-node.js';
+import { OperationNodeSource } from '../operation-node/operation-node-source.js';
+import { OrderedColumnName } from '../parser/reference-parser.js';
+import { CompiledQuery } from '../query-compiler/compiled-query.js';
+import { QueryExecutor } from '../query-executor/query-executor.js';
+import { Compilable } from '../util/compilable.js';
+import { QueryId } from '../util/query-id.js';
+export declare class AlterTableAddIndexBuilder implements OperationNodeSource, Compilable {
+    #private;
+    constructor(props: AlterTableAddIndexBuilderProps);
+    /**
+     * Makes the index unique.
+     */
+    unique(): AlterTableAddIndexBuilder;
+    /**
+     * Adds a column to the index.
+     *
+     * Also see {@link columns} for adding multiple columns at once or {@link expression}
+     * for specifying an arbitrary expression.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * await db.schema
+     *         .alterTable('person')
+     *         .createIndex('person_first_name_and_age_index')
+     *         .column('first_name')
+     *         .column('age desc')
+     *         .execute()
+     * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * alter table `person` add index `person_first_name_and_age_index` (`first_name`, `age` desc)
+     * ```
+     */
+    column<CL extends string>(column: OrderedColumnName<CL>): AlterTableAddIndexBuilder;
+    /**
+     * Specifies a list of columns for the index.
+     *
+     * Also see {@link column} for adding a single column or {@link expression} for
+     * specifying an arbitrary expression.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * await db.schema
+     *         .alterTable('person')
+     *         .addIndex('person_first_name_and_age_index')
+     *         .columns(['first_name', 'age desc'])
+     *         .execute()
+     * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * alter table `person` add index `person_first_name_and_age_index` (`first_name`, `age` desc)
+     * ```
+     */
+    columns<CL extends string>(columns: OrderedColumnName<CL>[]): AlterTableAddIndexBuilder;
+    /**
+     * Specifies an arbitrary expression for the index.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * import { sql } from 'kysely'
+     *
+     * await db.schema
+     *   .alterTable('person')
+     *   .addIndex('person_first_name_index')
+     *   .expression(sql`(first_name < 'Sami')`)
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * alter table `person` add index `person_first_name_index` ((first_name < 'Sami'))
+     * ```
+     */
+    expression(expression: Expression<any>): AlterTableAddIndexBuilder;
+    /**
+     * Specifies the index type.
+     */
+    using(indexType: IndexType): AlterTableAddIndexBuilder;
+    using(indexType: string): AlterTableAddIndexBuilder;
+    /**
+     * Simply calls the provided function passing `this` as the only argument. `$call` returns
+     * what the provided function returns.
+     */
+    $call<T>(func: (qb: this) => T): T;
+    toOperationNode(): AlterTableNode;
+    compile(): CompiledQuery;
+    execute(): Promise<void>;
+}
+export interface AlterTableAddIndexBuilderProps {
+    readonly queryId: QueryId;
+    readonly executor: QueryExecutor;
+    readonly node: AlterTableNode;
+}