kysely 0.26.2 → 0.27.0

package/dist/cjs/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/cjs/query-compiler/default-query-compiler.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DefaultQueryCompiler = void 0;
+const create_table_node_js_1 = require("../operation-node/create-table-node.js");
 const insert_query_node_js_1 = require("../operation-node/insert-query-node.js");
 const operation_node_visitor_js_1 = require("../operation-node/operation-node-visitor.js");
 const operator_node_js_1 = require("../operation-node/operator-node.js");
@@ -32,6 +33,7 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
         const wrapInParens = this.parentNode !== undefined &&
             !parens_node_js_1.ParensNode.is(this.parentNode) &&
             !insert_query_node_js_1.InsertQueryNode.is(this.parentNode) &&
+            !create_table_node_js_1.CreateTableNode.is(this.parentNode) &&
             !create_view_node_js_1.CreateViewNode.is(this.parentNode) &&
             !set_operation_node_js_1.SetOperationNode.is(this.parentNode);
         if (this.parentNode === undefined && node.explain) {
@@ -348,16 +350,22 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
             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) {
@@ -385,6 +393,9 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
         if (node.unique) {
             this.append(' unique');
         }
+        if (node.nullsNotDistinct) {
+            this.append(' nulls not distinct');
+        }
         if (node.primaryKey) {
             this.append(' primary key');
         }
@@ -565,6 +576,9 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
             this.compileList(node.columns);
             this.append(')');
         }
+        if (node.nullsNotDistinct) {
+            this.append(' nulls not distinct');
+        }
         if (node.where) {
             this.append(' ');
             this.visitNode(node.where);
@@ -617,7 +631,11 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
             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(')');
     }
@@ -698,7 +716,13 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
             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) {
@@ -720,7 +744,9 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
         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 ');
@@ -1006,6 +1032,23 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
             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;
     }
@@ -1079,6 +1122,16 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
             : 1);
         return (0, object_utils_js_1.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;
+    }
 }
 exports.DefaultQueryCompiler = DefaultQueryCompiler;
 const SELECT_MODIFIER_SQL = (0, object_utils_js_1.freeze)({

package/dist/cjs/query-creator.d.ts

@@ -11,7 +11,7 @@ import { DeleteResult } from './query-builder/delete-result.js';
 import { UpdateResult } from './query-builder/update-result.js';
 import { KyselyPlugin } from './plugin/kysely-plugin.js';
 import { CTEBuilderCallback } from './query-builder/cte-builder.js';
-import { SelectArg, SelectExpression, Selection } from './parser/select-parser.js';
+import { CallbackSelection, SelectCallback, SelectExpression, Selection } from './parser/select-parser.js';
 export declare class QueryCreator<DB> {
     #private;
     constructor(props: QueryCreatorProps);
@@ -139,7 +139,7 @@ export declare class QueryCreator<DB> {
      * ### Examples
      *
      * ```ts
-     * const result = db.select((eb) => [
+     * const result = db.selectNoFrom((eb) => [
      *   eb.selectFrom('person')
      *     .select('id')
      *     .where('first_name', '=', 'Jennifer')
@@ -174,7 +174,9 @@ export declare class QueryCreator<DB> {
      * ) as "doggo_id"
      * ```
      */
-    selectNoFrom<SE extends SelectExpression<DB, never>>(selection: SelectArg<DB, never, SE>): SelectQueryBuilder<DB, never, Selection<DB, never, SE>>;
+    selectNoFrom<SE extends SelectExpression<DB, never>>(selections: ReadonlyArray<SE>): SelectQueryBuilder<DB, never, Selection<DB, never, SE>>;
+    selectNoFrom<CB extends SelectCallback<DB, never>>(callback: CB): SelectQueryBuilder<DB, never, CallbackSelection<DB, never, CB>>;
+    selectNoFrom<SE extends SelectExpression<DB, never>>(selection: SE): SelectQueryBuilder<DB, never, Selection<DB, never, SE>>;
     /**
      * Creates an insert query.
      *

package/dist/cjs/query-creator.js

@@ -28,53 +28,6 @@ class QueryCreator {
             queryNode: select_query_node_js_1.SelectQueryNode.createFrom((0, table_parser_js_1.parseTableExpressionOrList)(from), this.#props.withNode),
         });
     }
-    /**
-     * Creates a `select` query builder without a `from` clause.
-     *
-     * If you want to create a `select from` query, use the `selectFrom` method instead.
-     * This one can be used to create a plain `select` statement without a `from` clause.
-     *
-     * This method accepts the same inputs as {@link SelectQueryBuilder.select}. See its
-     * documentation for more examples.
-     *
-     * ### Examples
-     *
-     * ```ts
-     * const result = db.select((eb) => [
-     *   eb.selectFrom('person')
-     *     .select('id')
-     *     .where('first_name', '=', 'Jennifer')
-     *     .limit(1)
-     *     .as('jennifer_id'),
-     *
-     *   eb.selectFrom('pet')
-     *     .select('id')
-     *     .where('name', '=', 'Doggo')
-     *     .limit(1)
-     *     .as('doggo_id')
-     *   ])
-     *   .executeTakeFirstOrThrow()
-     *
-     * console.log(result.jennifer_id)
-     * console.log(result.doggo_id)
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```sql
-     * select (
-     *   select "id"
-     *   from "person"
-     *   where "first_name" = $1
-     *   limit $2
-     * ) as "jennifer_id", (
-     *   select "id"
-     *   from "pet"
-     *   where "name" = $3
-     *   limit $4
-     * ) as "doggo_id"
-     * ```
-     */
     selectNoFrom(selection) {
         return (0, select_query_builder_js_1.createSelectQueryBuilder)({
             queryId: (0, query_id_js_1.createQueryId)(),

package/dist/cjs/raw-builder/raw-builder.d.ts

@@ -12,9 +12,6 @@ import { AliasableExpression, AliasedExpression, Expression } from '../expressio
  * use the {@link sql} template tag.
  */
 export interface RawBuilder<O> extends AliasableExpression<O> {
-    /**
-     * @private Without this SelectQueryBuilder extends RawBuilder and things break.
-     */
     get isRawBuilder(): true;
     /**
      * Returns an aliased version of the SQL expression.

package/dist/cjs/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;
+}

package/dist/cjs/schema/alter-table-add-index-builder.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AlterTableAddIndexBuilder = void 0;
+const add_index_node_js_1 = require("../operation-node/add-index-node.js");
+const alter_table_node_js_1 = require("../operation-node/alter-table-node.js");
+const raw_node_js_1 = require("../operation-node/raw-node.js");
+const reference_parser_js_1 = require("../parser/reference-parser.js");
+const object_utils_js_1 = require("../util/object-utils.js");
+const prevent_await_js_1 = require("../util/prevent-await.js");
+class AlterTableAddIndexBuilder {
+    #props;
+    constructor(props) {
+        this.#props = (0, object_utils_js_1.freeze)(props);
+    }
+    /**
+     * Makes the index unique.
+     */
+    unique() {
+        return new AlterTableAddIndexBuilder({
+            ...this.#props,
+            node: alter_table_node_js_1.AlterTableNode.cloneWithTableProps(this.#props.node, {
+                addIndex: add_index_node_js_1.AddIndexNode.cloneWith(this.#props.node.addIndex, {
+                    unique: true,
+                }),
+            }),
+        });
+    }
+    /**
+     * 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(column) {
+        return new AlterTableAddIndexBuilder({
+            ...this.#props,
+            node: alter_table_node_js_1.AlterTableNode.cloneWithTableProps(this.#props.node, {
+                addIndex: add_index_node_js_1.AddIndexNode.cloneWithColumns(this.#props.node.addIndex, [(0, reference_parser_js_1.parseOrderedColumnName)(column)]),
+            }),
+        });
+    }
+    /**
+     * 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(columns) {
+        return new AlterTableAddIndexBuilder({
+            ...this.#props,
+            node: alter_table_node_js_1.AlterTableNode.cloneWithTableProps(this.#props.node, {
+                addIndex: add_index_node_js_1.AddIndexNode.cloneWithColumns(this.#props.node.addIndex, columns.map(reference_parser_js_1.parseOrderedColumnName)),
+            }),
+        });
+    }
+    /**
+     * 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) {
+        return new AlterTableAddIndexBuilder({
+            ...this.#props,
+            node: alter_table_node_js_1.AlterTableNode.cloneWithTableProps(this.#props.node, {
+                addIndex: add_index_node_js_1.AddIndexNode.cloneWithColumns(this.#props.node.addIndex, [expression.toOperationNode()]),
+            }),
+        });
+    }
+    using(indexType) {
+        return new AlterTableAddIndexBuilder({
+            ...this.#props,
+            node: alter_table_node_js_1.AlterTableNode.cloneWithTableProps(this.#props.node, {
+                addIndex: add_index_node_js_1.AddIndexNode.cloneWith(this.#props.node.addIndex, {
+                    using: raw_node_js_1.RawNode.createWithSql(indexType),
+                }),
+            }),
+        });
+    }
+    /**
+     * Simply calls the provided function passing `this` as the only argument. `$call` returns
+     * what the provided function returns.
+     */
+    $call(func) {
+        return func(this);
+    }
+    toOperationNode() {
+        return this.#props.executor.transformQuery(this.#props.node, this.#props.queryId);
+    }
+    compile() {
+        return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);
+    }
+    async execute() {
+        await this.#props.executor.executeQuery(this.compile(), this.#props.queryId);
+    }
+}
+exports.AlterTableAddIndexBuilder = AlterTableAddIndexBuilder;
+(0, prevent_await_js_1.preventAwait)(AlterTableAddIndexBuilder, "don't await AlterTableAddIndexBuilder instances directly. To execute the query you need to call `execute`");

package/dist/cjs/schema/alter-table-builder.d.ts

@@ -11,6 +11,8 @@ import { AlterColumnBuilderCallback } from './alter-column-builder.js';
 import { AlterTableExecutor } from './alter-table-executor.js';
 import { AlterTableAddForeignKeyConstraintBuilder } from './alter-table-add-foreign-key-constraint-builder.js';
 import { AlterTableDropConstraintBuilder } from './alter-table-drop-constraint-builder.js';
+import { AlterTableAddIndexBuilder } from './alter-table-add-index-builder.js';
+import { UniqueConstraintNodeBuilderCallback } from './unique-constraint-builder.js';
 /**
  * This builder can be used to create a `alter table` query.
  */
@@ -35,7 +37,7 @@ export declare class AlterTableBuilder implements ColumnAlteringInterface {
     /**
      * See {@link CreateTableBuilder.addUniqueConstraint}
      */
-    addUniqueConstraint(constraintName: string, columns: string[]): AlterTableExecutor;
+    addUniqueConstraint(constraintName: string, columns: string[], build?: UniqueConstraintNodeBuilderCallback): AlterTableExecutor;
     /**
      * See {@link CreateTableBuilder.addCheckConstraint}
      */
@@ -53,6 +55,44 @@ export declare class AlterTableBuilder implements ColumnAlteringInterface {
      */
     addPrimaryKeyConstraint(constraintName: string, columns: string[]): AlterTableExecutor;
     dropConstraint(constraintName: string): AlterTableDropConstraintBuilder;
+    /**
+     * This can be used to add index to table.
+     *
+     *  ### Examples
+     *
+     * ```ts
+     * db.schema.alterTable('person')
+     *   .addIndex('person_email_index')
+     *   .column('email')
+     *   .unique()
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * alter table `person` add unique index `person_email_index` (`email`)
+     * ```
+     */
+    addIndex(indexName: string): AlterTableAddIndexBuilder;
+    /**
+     * This can be used to drop index from table.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.schema.alterTable('person')
+     *   .dropIndex('person_email_index')
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * alter table `person` drop index `test_first_name_index`
+     * ```
+     */
+    dropIndex(indexName: string): AlterTableExecutor;
     /**
      * Calls the given function passing `this` as the only argument.
      *

package/dist/cjs/schema/alter-table-builder.js

@@ -25,6 +25,10 @@ const alter_table_executor_js_1 = require("./alter-table-executor.js");
 const alter_table_add_foreign_key_constraint_builder_js_1 = require("./alter-table-add-foreign-key-constraint-builder.js");
 const alter_table_drop_constraint_builder_js_1 = require("./alter-table-drop-constraint-builder.js");
 const primary_constraint_node_js_1 = require("../operation-node/primary-constraint-node.js");
+const drop_index_node_js_1 = require("../operation-node/drop-index-node.js");
+const add_index_node_js_1 = require("../operation-node/add-index-node.js");
+const alter_table_add_index_builder_js_1 = require("./alter-table-add-index-builder.js");
+const unique_constraint_builder_js_1 = require("./unique-constraint-builder.js");
 /**
  * This builder can be used to create a `alter table` query.
  */
@@ -85,11 +89,12 @@ class AlterTableBuilder {
     /**
      * See {@link CreateTableBuilder.addUniqueConstraint}
      */
-    addUniqueConstraint(constraintName, columns) {
+    addUniqueConstraint(constraintName, columns, build = object_utils_js_1.noop) {
+        const uniqueConstraintBuilder = build(new unique_constraint_builder_js_1.UniqueConstraintNodeBuilder(unique_constraint_node_js_1.UniqueConstraintNode.create(columns, constraintName)));
         return new alter_table_executor_js_1.AlterTableExecutor({
             ...this.#props,
             node: alter_table_node_js_1.AlterTableNode.cloneWithTableProps(this.#props.node, {
-                addConstraint: add_constraint_node_js_1.AddConstraintNode.create(unique_constraint_node_js_1.UniqueConstraintNode.create(columns, constraintName)),
+                addConstraint: add_constraint_node_js_1.AddConstraintNode.create(uniqueConstraintBuilder.toOperationNode()),
             }),
         });
     }
@@ -136,6 +141,58 @@ class AlterTableBuilder {
             }),
         });
     }
+    /**
+     * This can be used to add index to table.
+     *
+     *  ### Examples
+     *
+     * ```ts
+     * db.schema.alterTable('person')
+     *   .addIndex('person_email_index')
+     *   .column('email')
+     *   .unique()
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * alter table `person` add unique index `person_email_index` (`email`)
+     * ```
+     */
+    addIndex(indexName) {
+        return new alter_table_add_index_builder_js_1.AlterTableAddIndexBuilder({
+            ...this.#props,
+            node: alter_table_node_js_1.AlterTableNode.cloneWithTableProps(this.#props.node, {
+                addIndex: add_index_node_js_1.AddIndexNode.create(indexName),
+            }),
+        });
+    }
+    /**
+     * This can be used to drop index from table.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.schema.alterTable('person')
+     *   .dropIndex('person_email_index')
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * alter table `person` drop index `test_first_name_index`
+     * ```
+     */
+    dropIndex(indexName) {
+        return new alter_table_executor_js_1.AlterTableExecutor({
+            ...this.#props,
+            node: alter_table_node_js_1.AlterTableNode.cloneWithTableProps(this.#props.node, {
+                dropIndex: drop_index_node_js_1.DropIndexNode.create(indexName),
+            }),
+        });
+    }
     /**
      * Calls the given function passing `this` as the only argument.
      *