kysely 0.2.2 → 0.2.6

package/lib/query-builder/query-builder.d.ts

@@ -14,7 +14,7 @@ import { AnyColumn, ManyResultRowType, SingleResultRowType } from './type-utils'
 import { OrderByExpression } from '../parser/order-by-parser';
 import { MutationObject } from '../parser/mutation-parser';
 import { Compilable } from '../util/compilable';
-import { QueryExecutor } from '../util/query-executor';
+import { QueryExecutor } from '../query-executor/query-executor';
 /**
  * The main query builder class.
  *
@@ -32,7 +32,7 @@ import { QueryExecutor } from '../util/query-executor';
  */
 export declare class QueryBuilder<DB, TB extends keyof DB, O = {}> implements OperationNodeSource, Compilable {
     #private;
-    constructor({ queryNode, executor }: QueryBuilderConstructorArgs);
+    constructor(args: QueryBuilderConstructorArgs);
     /**
      * Adds a `where` clause to the query.
      *
@@ -579,7 +579,7 @@ export declare class QueryBuilder<DB, TB extends keyof DB, O = {}> implements Op
      * person.id
      * ```
      */
-    select<S extends SelectExpression<DB, TB>>(selections: S[]): QueryBuilderWithSelection<DB, TB, O, S>;
+    select<S extends SelectExpression<DB, TB>>(selections: ReadonlyArray<S>): QueryBuilderWithSelection<DB, TB, O, S>;
     select<S extends SelectExpression<DB, TB>>(selection: S): QueryBuilderWithSelection<DB, TB, O, S>;
     /**
      * Adds `distinct on` selections to the select clause.
@@ -603,7 +603,7 @@ export declare class QueryBuilder<DB, TB extends keyof DB, O = {}> implements Op
      * where "pet"."name" = $1
      * ```
      */
-    distinctOn<S extends SelectExpression<DB, TB>>(selections: S[]): QueryBuilder<DB, TB, O>;
+    distinctOn<S extends SelectExpression<DB, TB>>(selections: ReadonlyArray<S>): QueryBuilder<DB, TB, O>;
     distinctOn<S extends SelectExpression<DB, TB>>(selection: S): QueryBuilder<DB, TB, O>;
     /**
      *
@@ -675,7 +675,7 @@ export declare class QueryBuilder<DB, TB extends keyof DB, O = {}> implements Op
      * select "person".*, "pet".* from "person", "pet"
      * ```
      */
-    selectAll<T extends TB>(table: T[]): SelectAllQueryBuilder<DB, TB, O, T>;
+    selectAll<T extends TB>(table: ReadonlyArray<T>): SelectAllQueryBuilder<DB, TB, O, T>;
     selectAll<T extends TB>(table: T): SelectAllQueryBuilder<DB, TB, O, T>;
     selectAll<T extends TB>(): SelectAllQueryBuilder<DB, TB, O, T>;
     /**
@@ -944,7 +944,7 @@ export declare class QueryBuilder<DB, TB extends keyof DB, O = {}> implements Op
      * ```
      */
     onConflictDoNothing(column: AnyColumn<DB, TB>): QueryBuilder<DB, TB, O>;
-    onConflictDoNothing(columns: AnyColumn<DB, TB>[]): QueryBuilder<DB, TB, O>;
+    onConflictDoNothing(columns: ReadonlyArray<AnyColumn<DB, TB>>): QueryBuilder<DB, TB, O>;
     /**
      * Ignores an insert if the column (or columns) given as the first
      * argument conflicts with the current rows in the database and
@@ -988,7 +988,7 @@ export declare class QueryBuilder<DB, TB extends keyof DB, O = {}> implements Op
      * ```
      */
     onConflictUpdate(column: AnyColumn<DB, TB>, updates: MutationObject<DB, TB>): QueryBuilder<DB, TB, O>;
-    onConflictUpdate(columns: AnyColumn<DB, TB>[], updates: MutationObject<DB, TB>): QueryBuilder<DB, TB, O>;
+    onConflictUpdate(columns: ReadonlyArray<AnyColumn<DB, TB>>, updates: MutationObject<DB, TB>): QueryBuilder<DB, TB, O>;
     /**
      * Sets the values to update for an `updateTable` query.
      *
@@ -1127,7 +1127,7 @@ export declare class QueryBuilder<DB, TB extends keyof DB, O = {}> implements Op
      *   .executeTakeFirst()
      * ```
      */
-    returning<S extends SelectExpression<DB, TB>>(selections: S[]): QueryBuilderWithReturning<DB, TB, O, S>;
+    returning<S extends SelectExpression<DB, TB>>(selections: ReadonlyArray<S>): QueryBuilderWithReturning<DB, TB, O, S>;
     returning<S extends SelectExpression<DB, TB>>(selection: S): QueryBuilderWithReturning<DB, TB, O, S>;
     /**
      * Adds a `returning *` to an insert/update/delete query on databases
@@ -1319,7 +1319,7 @@ export declare class QueryBuilder<DB, TB extends keyof DB, O = {}> implements Op
      * group by "first_name"
      * ```
      */
-    groupBy(orderBy: ReferenceExpression<DB, TB>[]): QueryBuilder<DB, TB, O>;
+    groupBy(orderBy: ReadonlyArray<ReferenceExpression<DB, TB>>): QueryBuilder<DB, TB, O>;
     groupBy(orderBy: ReferenceExpression<DB, TB>): QueryBuilder<DB, TB, O>;
     /**
      * Adds a limit clause to the query.

package/lib/query-builder/query-builder.js

@@ -18,7 +18,7 @@ const prevent_await_1 = require("../util/prevent-await");
 const limit_node_1 = require("../operation-node/limit-node");
 const offset_node_1 = require("../operation-node/offset-node");
 const object_utils_1 = require("../util/object-utils");
-const query_executor_1 = require("../util/query-executor");
+const query_executor_1 = require("../query-executor/query-executor");
 /**
  * The main query builder class.
  *
@@ -37,9 +37,9 @@ const query_executor_1 = require("../util/query-executor");
 class QueryBuilder {
     #queryNode;
     #executor;
-    constructor({ queryNode, executor }) {
-        this.#queryNode = queryNode;
-        this.#executor = executor;
+    constructor(args) {
+        this.#queryNode = args.queryNode;
+        this.#executor = args.executor;
     }
     where(...args) {
         ensureCanHaveWhereClause(this.#queryNode);
@@ -427,14 +427,14 @@ class QueryBuilder {
         ensureCanHaveOnConflict(this.#queryNode);
         return new QueryBuilder({
             executor: this.#executor,
-            queryNode: insert_query_node_1.insertQueryNode.cloneWithOnConflictDoNothing(this.#queryNode, object_utils_1.asArray(columns).map(reference_parser_1.parseColumnName)),
+            queryNode: insert_query_node_1.insertQueryNode.cloneWithOnConflictDoNothing(this.#queryNode, object_utils_1.asReadonlyArray(columns).map(reference_parser_1.parseColumnName)),
         });
     }
     onConflictUpdate(columns, updates) {
         ensureCanHaveOnConflict(this.#queryNode);
         return new QueryBuilder({
             executor: this.#executor,
-            queryNode: insert_query_node_1.insertQueryNode.cloneWithOnConflictUpdate(this.#queryNode, object_utils_1.asArray(columns).map(reference_parser_1.parseColumnName), update_set_parser_1.parseUpdateObject(updates)),
+            queryNode: insert_query_node_1.insertQueryNode.cloneWithOnConflictUpdate(this.#queryNode, object_utils_1.asReadonlyArray(columns).map(reference_parser_1.parseColumnName), update_set_parser_1.parseUpdateObject(updates)),
         });
     }
     /**

package/lib/query-builder/sub-query-builder.d.ts

@@ -1,4 +1,4 @@
-import { NeverExecutingQueryExecutor } from '../util/query-executor';
+import { NeverExecutingQueryExecutor } from '../query-executor/query-executor';
 import { TableExpression, QueryBuilderWithTable } from '../parser/table-parser';
 export declare class SubQueryBuilder<DB, TB extends keyof DB> {
     #private;

package/lib/query-builder/sub-query-builder.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SubQueryBuilder = void 0;
 const query_builder_1 = require("./query-builder");
 const select_query_node_1 = require("../operation-node/select-query-node");
-const query_executor_1 = require("../util/query-executor");
+const query_executor_1 = require("../query-executor/query-executor");
 const table_parser_1 = require("../parser/table-parser");
 const with_schema_transformer_1 = require("../transformers/with-schema-transformer");
 class SubQueryBuilder {

package/lib/query-compiler/default-query-compiler.d.ts

@@ -36,8 +36,8 @@ import { SelectAllNode } from '../operation-node/select-all-node';
 import { SelectQueryNode } from '../operation-node/select-query-node';
 import { SelectionNode } from '../operation-node/selection-node';
 import { TableNode } from '../operation-node/table-node';
-import { TablePrimaryConstraintNode } from '../operation-node/table-primary-constraint-node';
-import { TableUniqueConstraintNode } from '../operation-node/table-unique-constraint-node';
+import { PrimaryKeyConstraintNode } from '../operation-node/primary-constraint-node';
+import { UniqueConstraintNode } from '../operation-node/unique-constraint-node';
 import { UpdateQueryNode } from '../operation-node/update-query-node';
 import { ValueListNode } from '../operation-node/value-list-node';
 import { ValueNode } from '../operation-node/value-node';
@@ -50,6 +50,14 @@ import { CompileEntryPointNode, QueryCompiler } from './query-compiler';
 import { HavingNode } from '../operation-node/having-node';
 import { CreateSchemaNode } from '../operation-node/create-schema-node';
 import { DropSchemaNode } from '../operation-node/drop-schema-node';
+import { AlterTableNode } from '../operation-node/alter-table-node';
+import { DropColumnNode } from '../operation-node/drop-column-node';
+import { RenameColumnNode } from '../operation-node/rename-column-node';
+import { AlterColumnNode } from '../operation-node/alter-column-node';
+import { AddConstraintNode } from '../operation-node/add-constraint-node';
+import { DropConstraintNode } from '../operation-node/drop-constraint-node';
+import { ForeignKeyConstraintNode } from '../operation-node/foreign-key-constraint-node';
+import { ColumnDefinitionNode } from '../operation-node/column-definition-node';
 export declare class DefaultQueryCompiler extends OperationNodeVisitor implements QueryCompiler {
     #private;
     compileQuery(node: CompileEntryPointNode): CompiledQuery;
@@ -81,7 +89,7 @@ export declare class DefaultQueryCompiler extends OperationNodeVisitor implement
     protected visitOperator(node: OperatorNode): void;
     protected visitTable(node: TableNode): void;
     protected visitCreateTable(node: CreateTableNode): void;
-    protected visitAddColumn(node: AddColumnNode): void;
+    protected visitColumnDefinition(node: ColumnDefinitionNode): void;
     protected visitReferences(node: ReferencesNode): void;
     protected visitDropTable(node: DropTableNode): void;
     protected visitDataType(node: DataTypeNode): void;
@@ -98,12 +106,20 @@ export declare class DefaultQueryCompiler extends OperationNodeVisitor implement
     protected visitDropIndex(node: DropIndexNode): void;
     protected visitCreateSchema(node: CreateSchemaNode): void;
     protected visitDropSchema(node: DropSchemaNode): void;
-    protected visitTablePrimaryConstraint(node: TablePrimaryConstraintNode): void;
-    protected visitTableUniqueConstraint(node: TableUniqueConstraintNode): void;
+    protected visitPrimaryKeyConstraint(node: PrimaryKeyConstraintNode): void;
+    protected visitUniqueConstraint(node: UniqueConstraintNode): void;
     protected visitCheckConstraint(node: CheckConstraintNode): void;
+    protected visitForeignKeyConstraint(node: ForeignKeyConstraintNode): void;
     protected visitList(node: ListNode): void;
     protected visitWith(node: WithNode): void;
     protected visitCommonTableExpression(node: CommonTableExpressionNode): void;
+    protected visitAlterTable(node: AlterTableNode): void;
+    protected visitAddColumn(node: AddColumnNode): void;
+    protected visitRenameColumn(node: RenameColumnNode): void;
+    protected visitDropColumn(node: DropColumnNode): void;
+    protected visitAlterColumn(node: AlterColumnNode): void;
+    protected visitAddConstraint(node: AddConstraintNode): void;
+    protected visitDropConstraint(node: DropConstraintNode): void;
     protected appendLeftIdentifierWrapper(): void;
     protected appendRightIdentifierWrapper(): void;
     protected append(str: string): void;

package/lib/query-compiler/default-query-compiler.js

@@ -275,15 +275,10 @@ class DefaultQueryCompiler extends operation_node_visitor_1.OperationNodeVisitor
         }
         this.visitNode(node.table);
         this.append(' (');
-        this.compileList([
-            ...node.columns,
-            ...(node.primaryKeyConstraint ? [node.primaryKeyConstraint] : []),
-            ...(node.uniqueConstraints ?? []),
-            ...(node.checkConstraints ?? []),
-        ]);
+        this.compileList([...node.columns, ...(node.constraints ?? [])]);
         this.append(')');
     }
-    visitAddColumn(node) {
+    visitColumnDefinition(node) {
         this.visitNode(node.column);
         this.append(' ');
         if (node.isAutoIncrementing) {
@@ -325,7 +320,7 @@ class DefaultQueryCompiler extends operation_node_visitor_1.OperationNodeVisitor
         this.append('references ');
         this.visitNode(node.table);
         this.append(' (');
-        this.visitNode(node.column);
+        this.compileList(node.columns);
         this.append(')');
         if (node.onDelete) {
             this.append(' on delete ');
@@ -463,21 +458,47 @@ class DefaultQueryCompiler extends operation_node_visitor_1.OperationNodeVisitor
         }
         this.visitNode(node.schema);
     }
-    visitTablePrimaryConstraint(node) {
+    visitPrimaryKeyConstraint(node) {
+        if (node.name) {
+            this.append('constraint ');
+            this.visitNode(node.name);
+            this.append(' ');
+        }
         this.append('primary key (');
         this.compileList(node.columns);
         this.append(')');
     }
-    visitTableUniqueConstraint(node) {
+    visitUniqueConstraint(node) {
+        if (node.name) {
+            this.append('constraint ');
+            this.visitNode(node.name);
+            this.append(' ');
+        }
         this.append('unique (');
         this.compileList(node.columns);
         this.append(')');
     }
     visitCheckConstraint(node) {
+        if (node.name) {
+            this.append('constraint ');
+            this.visitNode(node.name);
+            this.append(' ');
+        }
         this.append('check (');
         this.visitNode(node.expression);
         this.append(')');
     }
+    visitForeignKeyConstraint(node) {
+        if (node.name) {
+            this.append('constraint ');
+            this.visitNode(node.name);
+            this.append(' ');
+        }
+        this.append('foreign key (');
+        this.compileList(node.columns);
+        this.append(') ');
+        this.visitNode(node.references);
+    }
     visitList(node) {
         this.compileList(node.items);
     }
@@ -490,6 +511,85 @@ class DefaultQueryCompiler extends operation_node_visitor_1.OperationNodeVisitor
         this.append(' as ');
         this.visitNode(node.expression);
     }
+    visitAlterTable(node) {
+        this.append('alter table ');
+        this.visitNode(node.table);
+        this.append(' ');
+        if (node.renameTo) {
+            this.append('rename to ');
+            this.visitNode(node.renameTo);
+        }
+        if (node.setSchema) {
+            this.append('set schema ');
+            this.visitNode(node.setSchema);
+        }
+        if (node.addConstraint) {
+            this.visitNode(node.addConstraint);
+        }
+        if (node.dropConstraint) {
+            this.visitNode(node.dropConstraint);
+        }
+        if (node.renameColumn) {
+            this.visitNode(node.renameColumn);
+        }
+        if (node.addColumn) {
+            this.visitNode(node.addColumn);
+        }
+        if (node.dropColumn) {
+            this.visitNode(node.dropColumn);
+        }
+        if (node.alterColumn) {
+            this.visitNode(node.alterColumn);
+        }
+    }
+    visitAddColumn(node) {
+        this.append('add column ');
+        this.visitNode(node.column);
+    }
+    visitRenameColumn(node) {
+        this.append('rename column ');
+        this.visitNode(node.column);
+        this.append(' to ');
+        this.visitNode(node.renameTo);
+    }
+    visitDropColumn(node) {
+        this.append('drop column ');
+        this.visitNode(node.column);
+    }
+    visitAlterColumn(node) {
+        this.append('alter column ');
+        this.visitNode(node.column);
+        this.append(' ');
+        if (node.dataType) {
+            this.append('type ');
+            this.visitNode(node.dataType);
+            if (node.dataTypeExpression) {
+                this.append('using ');
+                this.visitNode(node.dataTypeExpression);
+            }
+        }
+        if (node.setDefault) {
+            this.append('set default ');
+            this.visitNode(node.setDefault);
+        }
+        if (node.dropDefault) {
+            this.append('drop default');
+        }
+        if (node.setNotNull) {
+            this.append('set not null');
+        }
+        if (node.dropNotNull) {
+            this.append('drop not null');
+        }
+    }
+    visitAddConstraint(node) {
+        this.append('add ');
+        this.visitNode(node.constraint);
+    }
+    visitDropConstraint(node) {
+        this.append('drop constraint ');
+        this.visitNode(node.constraintName);
+    }
     appendLeftIdentifierWrapper() {
         this.append('"');
     }

package/lib/query-compiler/query-compiler.d.ts

@@ -1,3 +1,4 @@
+import { AlterTableNode } from '../operation-node/alter-table-node';
 import { CreateIndexNode } from '../operation-node/create-index-node';
 import { CreateSchemaNode } from '../operation-node/create-schema-node';
 import { CreateTableNode } from '../operation-node/create-table-node';
@@ -7,7 +8,7 @@ import { DropTableNode } from '../operation-node/drop-table-node';
 import { QueryNode } from '../operation-node/query-node';
 import { RawNode } from '../operation-node/raw-node';
 import { CompiledQuery } from './compiled-query';
-export declare type CompileEntryPointNode = QueryNode | CreateTableNode | CreateIndexNode | DropTableNode | DropIndexNode | CreateSchemaNode | DropSchemaNode | RawNode;
+export declare type CompileEntryPointNode = QueryNode | CreateTableNode | CreateIndexNode | AlterTableNode | DropTableNode | DropIndexNode | CreateSchemaNode | DropSchemaNode | RawNode;
 export interface QueryCompiler {
     compileQuery(node: CompileEntryPointNode): CompiledQuery;
 }

package/lib/query-creator.d.ts

@@ -1,7 +1,7 @@
 import { QueryBuilder } from './query-builder/query-builder';
 import { QueryBuilderWithTable, TableExpression, TableReference } from './parser/table-parser';
 import { InsertResultTypeTag, DeleteResultTypeTag, UpdateResultTypeTag } from './query-builder/type-utils';
-import { QueryExecutor } from './util/query-executor';
+import { QueryExecutor } from './query-executor/query-executor';
 import { RawBuilder } from './raw-builder/raw-builder';
 import { CommonTableExpression, QueryCreatorWithCommonTableExpression } from './parser/with-parser';
 import { WithNode } from './operation-node/with-node';
@@ -238,7 +238,7 @@ export declare class QueryCreator<DB> {
      * ```
      *
      * @example
-     * `withSchema` is smart enough to not add schema for aliases
+     * `withSchema` is smart enough to not add schema for aliases,
      * common table expressions or other places where the schema
      * doesn't belong to:
      *

package/lib/query-creator.js

@@ -163,7 +163,7 @@ class QueryCreator {
      * ```
      *
      * @example
-     * `withSchema` is smart enough to not add schema for aliases
+     * `withSchema` is smart enough to not add schema for aliases,
      * common table expressions or other places where the schema
      * doesn't belong to:
      *

package/lib/{util → query-executor}/query-executor.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NeverExecutingQueryExecutor = exports.DefaultQueryExecutor = exports.QueryExecutor = void 0;
-const object_utils_1 = require("./object-utils");
+const object_utils_1 = require("../util/object-utils");
 class QueryExecutor {
     #transformers;
     constructor(transformers = []) {

package/lib/raw-builder/raw-builder.d.ts

@@ -3,10 +3,10 @@ import { AliasNode } from '../operation-node/alias-node';
 import { OperationNodeSource } from '../operation-node/operation-node-source';
 import { RawNode } from '../operation-node/raw-node';
 import { CompiledQuery } from '../query-compiler/compiled-query';
-import { QueryExecutor } from '../util/query-executor';
+import { QueryExecutor } from '../query-executor/query-executor';
 export declare class RawBuilder<O = unknown> implements OperationNodeSource {
     #private;
-    constructor({ sql, params, executor }: RawBuilderConstructorArgs);
+    constructor(args: RawBuilderConstructorArgs);
     toOperationNode(): RawNode;
     as<A extends string>(alias: A): AliasedRawBuilder<O, A>;
     compile(): CompiledQuery;

package/lib/raw-builder/raw-builder.js

@@ -11,10 +11,10 @@ class RawBuilder {
     #sql;
     #params;
     #executor;
-    constructor({ sql, params, executor }) {
-        this.#sql = sql;
-        this.#params = params;
-        this.#executor = executor;
+    constructor(args) {
+        this.#sql = args.sql;
+        this.#params = args.params;
+        this.#executor = args.executor;
     }
     toOperationNode() {
         const bindingRegex = /(\?\??)/g;

package/lib/schema/alter-table-builder.d.ts

@@ -0,0 +1,64 @@
+import { ColumnDefinitionBuilder, ColumnDefinitionBuilderInterface } from '..';
+import { AlterColumnNode } from '../operation-node/alter-column-node';
+import { AlterTableNode } from '../operation-node/alter-table-node';
+import { ColumnDataType } from '../operation-node/data-type-node';
+import { OperationNodeSource } from '../operation-node/operation-node-source';
+import { OnDelete } from '../operation-node/references-node';
+import { CompiledQuery } from '../query-compiler/compiled-query';
+import { RawBuilder } from '../raw-builder/raw-builder';
+import { Compilable } from '../util/compilable';
+import { PrimitiveValue } from '../util/object-utils';
+import { QueryExecutor } from '../query-executor/query-executor';
+export declare class AlterTableBuilder {
+    #private;
+    constructor(args: AlterTableBuilderConstructorArgs);
+    renameTo(newTableName: string): AlterTableExecutor;
+    setSchema(newSchema: string): AlterTableExecutor;
+    alterColumn(column: string): AlterColumnBuilder;
+    dropColumn(column: string): AlterTableExecutor;
+    renameColumn(column: string, newColumn: string): AlterTableExecutor;
+    addColumn(columnName: string, dataType: ColumnDataType | RawBuilder): AlterTableAddColumnBuilder;
+}
+export declare class AlterColumnBuilder {
+    #private;
+    constructor(args: AlterColumnBuilderConstructorArgs);
+    setDataType(dataType: ColumnDataType): AlterTableExecutor;
+    setDefault(value: PrimitiveValue | RawBuilder<any>): AlterTableExecutor;
+    dropDefault(): AlterTableExecutor;
+    setNotNull(): AlterTableExecutor;
+    dropNotNull(): AlterTableExecutor;
+}
+export declare class AlterTableExecutor implements OperationNodeSource, Compilable {
+    #private;
+    constructor(args: AlterTableExecutorConstructorArgs);
+    toOperationNode(): AlterTableNode;
+    compile(): CompiledQuery;
+    execute(): Promise<void>;
+}
+export declare class AlterTableAddColumnBuilder implements ColumnDefinitionBuilderInterface<AlterTableAddColumnBuilder> {
+    #private;
+    constructor(args: AlterTableAddColumnBuilderConstructorArgs);
+    increments(): AlterTableAddColumnBuilder;
+    primaryKey(): AlterTableAddColumnBuilder;
+    references(ref: string): AlterTableAddColumnBuilder;
+    onDelete(onDelete: OnDelete): AlterTableAddColumnBuilder;
+    unique(): AlterTableAddColumnBuilder;
+    notNull(): AlterTableAddColumnBuilder;
+    defaultTo(value: PrimitiveValue | RawBuilder<any>): AlterTableAddColumnBuilder;
+    check(sql: string): AlterTableAddColumnBuilder;
+    toOperationNode(): AlterTableNode;
+    compile(): CompiledQuery;
+    execute(): Promise<void>;
+}
+export interface AlterTableBuilderConstructorArgs {
+    alterTableNode: AlterTableNode;
+    executor: QueryExecutor;
+}
+export interface AlterColumnBuilderConstructorArgs extends AlterTableBuilderConstructorArgs {
+    alterColumnNode: AlterColumnNode;
+}
+export interface AlterTableExecutorConstructorArgs extends AlterTableBuilderConstructorArgs {
+}
+export interface AlterTableAddColumnBuilderConstructorArgs extends AlterTableBuilderConstructorArgs {
+    columnBuilder: ColumnDefinitionBuilder;
+}