kysely 0.21.6 → 0.23.0

package/dist/esm/schema/column-definition-builder.d.ts

@@ -1,9 +1,11 @@
 import { OperationNodeSource } from '../operation-node/operation-node-source.js';
 import { OnModifyForeignAction } from '../operation-node/references-node.js';
 import { ColumnDefinitionNode } from '../operation-node/column-definition-node.js';
-import { AnyRawBuilder } from '../util/type-utils.js';
 import { DefaultValueExpression } from '../parser/default-value-parser.js';
-export interface ColumnDefinitionBuilderInterface {
+import { Expression } from '../expression/expression.js';
+export declare class ColumnDefinitionBuilder implements OperationNodeSource {
+    #private;
+    constructor(node: ColumnDefinitionNode);
     /**
      * Adds `auto_increment` or `autoincrement` to the column definition
      * depending on the dialect.
@@ -11,14 +13,14 @@ export interface ColumnDefinitionBuilderInterface {
      * Some dialects like PostgreSQL don't support this. On PostgreSQL
      * you can use the `serial` or `bigserial` data type instead.
      */
-    autoIncrement(): ColumnDefinitionBuilderInterface;
+    autoIncrement(): ColumnDefinitionBuilder;
     /**
      * Makes the column the primary key.
      *
      * If you want to specify a composite primary key use the
      * {@link CreateTableBuilder.addPrimaryKeyConstraint} method.
      */
-    primaryKey(): ColumnDefinitionBuilderInterface;
+    primaryKey(): ColumnDefinitionBuilder;
     /**
      * Adds a foreign key constraint for the column.
      *
@@ -32,7 +34,7 @@ export interface ColumnDefinitionBuilderInterface {
      * col.references('person.id')
      * ```
      */
-    references(ref: string): ColumnDefinitionBuilderInterface;
+    references(ref: string): ColumnDefinitionBuilder;
     /**
      * Adds an `on delete` constraint for the foreign key column.
      *
@@ -46,7 +48,7 @@ export interface ColumnDefinitionBuilderInterface {
      * col.references('person.id').onDelete('cascade')
      * ```
      */
-    onDelete(onDelete: OnModifyForeignAction): ColumnDefinitionBuilderInterface;
+    onDelete(onDelete: OnModifyForeignAction): ColumnDefinitionBuilder;
     /**
      * Adds an `on update` constraint for the foreign key column.
      *
@@ -56,21 +58,21 @@ export interface ColumnDefinitionBuilderInterface {
      * col.references('person.id').onUpdate('cascade')
      * ```
      */
-    onUpdate(onUpdate: OnModifyForeignAction): ColumnDefinitionBuilderInterface;
+    onUpdate(onUpdate: OnModifyForeignAction): ColumnDefinitionBuilder;
     /**
      * Adds a unique constraint for the column.
      */
-    unique(): ColumnDefinitionBuilderInterface;
+    unique(): ColumnDefinitionBuilder;
     /**
      * Adds a `not null` constraint for the column.
      */
-    notNull(): ColumnDefinitionBuilderInterface;
+    notNull(): ColumnDefinitionBuilder;
     /**
      * Adds a `unsigned` modifier for the column.
      *
      * This only works on some dialects like MySQL.
      */
-    unsigned(): ColumnDefinitionBuilderInterface;
+    unsigned(): ColumnDefinitionBuilder;
     /**
      * Adds a default value constraint for the column.
      *
@@ -99,7 +101,7 @@ export interface ColumnDefinitionBuilderInterface {
      *   .execute()
      * ```
      */
-    defaultTo(value: DefaultValueExpression): ColumnDefinitionBuilderInterface;
+    defaultTo(value: DefaultValueExpression): ColumnDefinitionBuilder;
     /**
      * Adds a check constraint for the column.
      *
@@ -116,7 +118,7 @@ export interface ColumnDefinitionBuilderInterface {
      *   .execute()
      * ```
      */
-    check(expression: AnyRawBuilder): ColumnDefinitionBuilderInterface;
+    check(expression: Expression<any>): ColumnDefinitionBuilder;
     /**
      * Makes the column a generated column using a `generated always as` statement.
      *
@@ -133,15 +135,15 @@ export interface ColumnDefinitionBuilderInterface {
      *   .execute()
      * ```
      */
-    generatedAlwaysAs(expression: AnyRawBuilder): ColumnDefinitionBuilderInterface;
+    generatedAlwaysAs(expression: Expression<any>): ColumnDefinitionBuilder;
     /**
      * Adds the `generated always as identity` specifier on supported dialects.
      */
-    generatedAlwaysAsIdentity(): ColumnDefinitionBuilderInterface;
+    generatedAlwaysAsIdentity(): ColumnDefinitionBuilder;
     /**
      * Adds the `generated by default as identity` specifier on supported dialects.
      */
-    generatedByDefaultAsIdentity(): ColumnDefinitionBuilderInterface;
+    generatedByDefaultAsIdentity(): ColumnDefinitionBuilder;
     /**
      * Makes a generated column stored instead of virtual. This method can only
      * be used with {@link generatedAlwaysAs}
@@ -158,165 +160,51 @@ export interface ColumnDefinitionBuilderInterface {
      *   .execute()
      * ```
      */
-    stored(): ColumnDefinitionBuilderInterface;
-}
-export declare class ColumnDefinitionBuilder implements ColumnDefinitionBuilderInterface, OperationNodeSource {
-    #private;
-    constructor(node: ColumnDefinitionNode);
-    /**
-     * Adds `auto_increment` or `autoincrement` to the column definition
-     * depending on the dialect.
-     *
-     * Some dialects like PostgreSQL don't support this. On PostgreSQL
-     * you can use the `serial` or `bigserial` data type instead.
-     */
-    autoIncrement(): ColumnDefinitionBuilder;
-    /**
-     * Makes the column the primary key.
-     *
-     * If you want to specify a composite primary key use the
-     * {@link CreateTableBuilder.addPrimaryKeyConstraint} method.
-     */
-    primaryKey(): ColumnDefinitionBuilder;
-    /**
-     * Adds a foreign key constraint for the column.
-     *
-     * If your database engine doesn't support foreign key constraints in the
-     * column definition (like MySQL 5) you need to call the table level
-     * {@link CreateTableBuilder.addForeignKeyConstraint} method instead.
-     *
-     * ### Examples
-     *
-     * ```ts
-     * col.references('person.id')
-     * ```
-     */
-    references(ref: string): ColumnDefinitionBuilder;
-    /**
-     * Adds an `on delete` constraint for the foreign key column.
-     *
-     * If your database engine doesn't support foreign key constraints in the
-     * column definition (like MySQL 5) you need to call the table level
-     * {@link CreateTableBuilder.addForeignKeyConstraint} method instead.
-     *
-     * ### Examples
-     *
-     * ```ts
-     * col.references('person.id').onDelete('cascade')
-     * ```
-     */
-    onDelete(onDelete: OnModifyForeignAction): ColumnDefinitionBuilder;
-    /**
-     * Adds an `on update` constraint for the foreign key column.
-     *
-     * ### Examples
-     *
-     * ```ts
-     * col.references('person.id').onUpdate('cascade')
-     * ```
-     */
-    onUpdate(onUpdate: OnModifyForeignAction): ColumnDefinitionBuilder;
-    /**
-     * Adds a unique constraint for the column.
-     */
-    unique(): ColumnDefinitionBuilder;
-    /**
-     * Adds a `not null` constraint for the column.
-     */
-    notNull(): ColumnDefinitionBuilder;
-    /**
-     * Adds a `unsigned` modifier for the column.
-     *
-     * This only works on some dialects like MySQL.
-     */
-    unsigned(): ColumnDefinitionBuilder;
+    stored(): ColumnDefinitionBuilder;
     /**
-     * Adds a default value constraint for the column.
+     * This can be used to add any additional SQL right after the column's data type.
      *
      * ### Examples
      *
      * ```ts
-     * db.schema
-     *   .createTable('pet')
-     *   .addColumn('number_of_legs', 'integer', (col) => col.defaultTo(4))
-     *   .execute()
+     * db.schema.createTable('person')
+     *  .addColumn('id', 'integer', col => col.primaryKey())
+     *  .addColumn('first_name', 'varchar(36)', col => col.modifyFront(sql`collate utf8mb4_general_ci`).notNull())
+     *  .execute()
      * ```
      *
-     * Values passed to `defaultTo` are interpreted as value literals by default. You can define
-     * an arbitrary SQL expression using the {@link sql} template tag:
-     *
-     * ```ts
-     * import { sql } from 'kysely'
+     * The generated SQL (MySQL):
      *
-     * db.schema
-     *   .createTable('pet')
-     *   .addColumn(
-     *     'number_of_legs',
-     *     'integer',
-     *     (col) => col.defaultTo(sql`any SQL here`)
-     *   )
-     *   .execute()
+     * ```sql
+     * create table `person` (
+     *   `id` integer primary key,
+     *   `first_name` varchar(36) collate utf8mb4_general_ci not null
+     * )
      * ```
      */
-    defaultTo(value: DefaultValueExpression): ColumnDefinitionBuilder;
+    modifyFront(modifier: Expression<any>): ColumnDefinitionBuilder;
     /**
-     * Adds a check constraint for the column.
+     * This can be used to add any additional SQL to the end of the column definition.
      *
      * ### Examples
      *
      * ```ts
-     * import { sql } from 'kysely'
-     *
-     * db.schema
-     *   .createTable('pet')
-     *   .addColumn('number_of_legs', 'integer', (col) =>
-     *     col.check(sql`number_of_legs < 5`)
-     *   )
-     *   .execute()
+     * db.schema.createTable('person')
+     *  .addColumn('id', 'integer', col => col.primaryKey())
+     *  .addColumn('age', 'integer', col => col.unsigned().notNull().modifyEnd(sql`comment ${sql.literal('it is not polite to ask a woman her age')}`))
+     *  .execute()
      * ```
-     */
-    check(expression: AnyRawBuilder): ColumnDefinitionBuilder;
-    /**
-     * Makes the column a generated column using a `generated always as` statement.
      *
-     * ### Examples
-     *
-     * ```ts
-     * import { sql } from 'kysely'
+     * The generated SQL (MySQL):
      *
-     * db.schema
-     *   .createTable('person')
-     *   .addColumn('full_name', 'varchar(255)',
-     *     (col) => col.generatedAlwaysAs(sql`concat(first_name, ' ', last_name)`)
-     *   )
-     *   .execute()
+     * ```sql
+     * create table `person` (
+     *   `id` integer primary key,
+     *   `age` integer unsigned not null comment 'it is not polite to ask a woman her age'
+     * )
      * ```
      */
-    generatedAlwaysAs(expression: AnyRawBuilder): ColumnDefinitionBuilder;
-    /**
-     * Adds the `generated always as identity` specifier on supported dialects.
-     */
-    generatedAlwaysAsIdentity(): ColumnDefinitionBuilder;
-    /**
-     * Adds the `generated by default as identity` specifier on supported dialects.
-     */
-    generatedByDefaultAsIdentity(): ColumnDefinitionBuilder;
-    /**
-     * Makes a generated column stored instead of virtual. This method can only
-     * be used with {@link generatedAlwaysAs}
-     *
-     * ### Examples
-     *
-     * ```ts
-     * db.schema
-     *   .createTable('person')
-     *   .addColumn('full_name', 'varchar(255)', (col) => col
-     *     .generatedAlwaysAs("concat(first_name, ' ', last_name)")
-     *     .stored()
-     *   )
-     *   .execute()
-     * ```
-     */
-    stored(): ColumnDefinitionBuilder;
+    modifyEnd(modifier: Expression<any>): ColumnDefinitionBuilder;
     toOperationNode(): ColumnDefinitionNode;
 }
+export declare type ColumnDefinitionBuilderCallback = (builder: ColumnDefinitionBuilder) => ColumnDefinitionBuilder;

package/dist/esm/schema/column-definition-builder.js

@@ -15,12 +15,38 @@ export class ColumnDefinitionBuilder {
     constructor(node) {
         this.#node = node;
     }
+    /**
+     * Adds `auto_increment` or `autoincrement` to the column definition
+     * depending on the dialect.
+     *
+     * Some dialects like PostgreSQL don't support this. On PostgreSQL
+     * you can use the `serial` or `bigserial` data type instead.
+     */
     autoIncrement() {
         return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, { autoIncrement: true }));
     }
+    /**
+     * Makes the column the primary key.
+     *
+     * If you want to specify a composite primary key use the
+     * {@link CreateTableBuilder.addPrimaryKeyConstraint} method.
+     */
     primaryKey() {
         return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, { primaryKey: true }));
     }
+    /**
+     * Adds a foreign key constraint for the column.
+     *
+     * If your database engine doesn't support foreign key constraints in the
+     * column definition (like MySQL 5) you need to call the table level
+     * {@link CreateTableBuilder.addForeignKeyConstraint} method instead.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * col.references('person.id')
+     * ```
+     */
     references(ref) {
         const references = parseStringReference(ref);
         if (!ReferenceNode.is(references) || SelectAllNode.is(references.column)) {
@@ -32,6 +58,19 @@ export class ColumnDefinitionBuilder {
             ]),
         }));
     }
+    /**
+     * Adds an `on delete` constraint for the foreign key column.
+     *
+     * If your database engine doesn't support foreign key constraints in the
+     * column definition (like MySQL 5) you need to call the table level
+     * {@link CreateTableBuilder.addForeignKeyConstraint} method instead.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * col.references('person.id').onDelete('cascade')
+     * ```
+     */
     onDelete(onDelete) {
         if (!this.#node.references) {
             throw new Error('on delete constraint can only be added for foreign keys');
@@ -40,6 +79,15 @@ export class ColumnDefinitionBuilder {
             references: ReferencesNode.cloneWithOnDelete(this.#node.references, parseOnModifyForeignAction(onDelete)),
         }));
     }
+    /**
+     * Adds an `on update` constraint for the foreign key column.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * col.references('person.id').onUpdate('cascade')
+     * ```
+     */
     onUpdate(onUpdate) {
         if (!this.#node.references) {
             throw new Error('on update constraint can only be added for foreign keys');
@@ -48,40 +96,133 @@ export class ColumnDefinitionBuilder {
             references: ReferencesNode.cloneWithOnUpdate(this.#node.references, parseOnModifyForeignAction(onUpdate)),
         }));
     }
+    /**
+     * Adds a unique constraint for the column.
+     */
     unique() {
         return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, { unique: true }));
     }
+    /**
+     * Adds a `not null` constraint for the column.
+     */
     notNull() {
         return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, { notNull: true }));
     }
+    /**
+     * Adds a `unsigned` modifier for the column.
+     *
+     * This only works on some dialects like MySQL.
+     */
     unsigned() {
         return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, { unsigned: true }));
     }
+    /**
+     * Adds a default value constraint for the column.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.schema
+     *   .createTable('pet')
+     *   .addColumn('number_of_legs', 'integer', (col) => col.defaultTo(4))
+     *   .execute()
+     * ```
+     *
+     * Values passed to `defaultTo` are interpreted as value literals by default. You can define
+     * an arbitrary SQL expression using the {@link sql} template tag:
+     *
+     * ```ts
+     * import { sql } from 'kysely'
+     *
+     * db.schema
+     *   .createTable('pet')
+     *   .addColumn(
+     *     'number_of_legs',
+     *     'integer',
+     *     (col) => col.defaultTo(sql`any SQL here`)
+     *   )
+     *   .execute()
+     * ```
+     */
     defaultTo(value) {
         return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, {
             defaultTo: DefaultValueNode.create(parseDefaultValueExpression(value)),
         }));
     }
+    /**
+     * Adds a check constraint for the column.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * import { sql } from 'kysely'
+     *
+     * db.schema
+     *   .createTable('pet')
+     *   .addColumn('number_of_legs', 'integer', (col) =>
+     *     col.check(sql`number_of_legs < 5`)
+     *   )
+     *   .execute()
+     * ```
+     */
     check(expression) {
         return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, {
             check: CheckConstraintNode.create(expression.toOperationNode()),
         }));
     }
+    /**
+     * Makes the column a generated column using a `generated always as` statement.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * import { sql } from 'kysely'
+     *
+     * db.schema
+     *   .createTable('person')
+     *   .addColumn('full_name', 'varchar(255)',
+     *     (col) => col.generatedAlwaysAs(sql`concat(first_name, ' ', last_name)`)
+     *   )
+     *   .execute()
+     * ```
+     */
     generatedAlwaysAs(expression) {
         return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, {
             generated: GeneratedNode.createWithExpression(expression.toOperationNode()),
         }));
     }
+    /**
+     * Adds the `generated always as identity` specifier on supported dialects.
+     */
     generatedAlwaysAsIdentity() {
         return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, {
             generated: GeneratedNode.create({ identity: true, always: true }),
         }));
     }
+    /**
+     * Adds the `generated by default as identity` specifier on supported dialects.
+     */
     generatedByDefaultAsIdentity() {
         return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, {
             generated: GeneratedNode.create({ identity: true, byDefault: true }),
         }));
     }
+    /**
+     * Makes a generated column stored instead of virtual. This method can only
+     * be used with {@link generatedAlwaysAs}
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.schema
+     *   .createTable('person')
+     *   .addColumn('full_name', 'varchar(255)', (col) => col
+     *     .generatedAlwaysAs("concat(first_name, ' ', last_name)")
+     *     .stored()
+     *   )
+     *   .execute()
+     * ```
+     */
     stored() {
         if (!this.#node.generated) {
             throw new Error('stored() can only be called after generatedAlwaysAs');
@@ -92,6 +233,54 @@ export class ColumnDefinitionBuilder {
             }),
         }));
     }
+    /**
+     * This can be used to add any additional SQL right after the column's data type.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.schema.createTable('person')
+     *  .addColumn('id', 'integer', col => col.primaryKey())
+     *  .addColumn('first_name', 'varchar(36)', col => col.modifyFront(sql`collate utf8mb4_general_ci`).notNull())
+     *  .execute()
+     * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * create table `person` (
+     *   `id` integer primary key,
+     *   `first_name` varchar(36) collate utf8mb4_general_ci not null
+     * )
+     * ```
+     */
+    modifyFront(modifier) {
+        return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWithFrontModifier(this.#node, modifier.toOperationNode()));
+    }
+    /**
+     * This can be used to add any additional SQL to the end of the column definition.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.schema.createTable('person')
+     *  .addColumn('id', 'integer', col => col.primaryKey())
+     *  .addColumn('age', 'integer', col => col.unsigned().notNull().modifyEnd(sql`comment ${sql.literal('it is not polite to ask a woman her age')}`))
+     *  .execute()
+     * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * create table `person` (
+     *   `id` integer primary key,
+     *   `age` integer unsigned not null comment 'it is not polite to ask a woman her age'
+     * )
+     * ```
+     */
+    modifyEnd(modifier) {
+        return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWithEndModifier(this.#node, modifier.toOperationNode()));
+    }
     toOperationNode() {
         return this.#node;
     }

package/dist/esm/schema/create-index-builder.d.ts

@@ -4,7 +4,7 @@ import { CompiledQuery } from '../query-compiler/compiled-query.js';
 import { Compilable } from '../util/compilable.js';
 import { QueryExecutor } from '../query-executor/query-executor.js';
 import { QueryId } from '../util/query-id.js';
-import { AnyRawBuilder } from '../util/type-utils.js';
+import { Expression } from '../expression/expression.js';
 export declare class CreateIndexBuilder implements OperationNodeSource, Compilable {
     #private;
     constructor(props: CreateIndexBuilderProps);
@@ -43,7 +43,7 @@ export declare class CreateIndexBuilder implements OperationNodeSource, Compilab
      *   .execute()
      * ```
      */
-    expression(expression: AnyRawBuilder): CreateIndexBuilder;
+    expression(expression: Expression<any>): CreateIndexBuilder;
     /**
      * Specifies the index type.
      */

package/dist/esm/schema/create-table-builder.d.ts

@@ -7,7 +7,7 @@ import { ColumnDefinitionBuilder } from './column-definition-builder.js';
 import { QueryId } from '../util/query-id.js';
 import { ForeignKeyConstraintBuilder } from './foreign-key-constraint-builder.js';
 import { DataTypeExpression } from '../parser/data-type-parser.js';
-import { AnyRawBuilder } from '../util/type-utils.js';
+import { Expression } from '../expression/expression.js';
 /**
  * This builder can be used to create a `create table` query.
  */
@@ -118,7 +118,7 @@ export declare class CreateTableBuilder<TB extends string, C extends string = ne
      * addCheckConstraint('check_legs', sql`number_of_legs < 5`)
      * ```
      */
-    addCheckConstraint(constraintName: string, checkExpression: AnyRawBuilder): CreateTableBuilder<TB, C>;
+    addCheckConstraint(constraintName: string, checkExpression: Expression<any>): CreateTableBuilder<TB, C>;
     /**
      * Adds a foreign key constraint.
      *
@@ -159,7 +159,7 @@ export declare class CreateTableBuilder<TB extends string, C extends string = ne
      * ```ts
      * db.schema.createTable('person')
      *   .modifyFront(sql`global temporary`)
-     *   .addColumn('id', 'integer', col => col => primaryKey())
+     *   .addColumn('id', 'integer', col => col.primaryKey())
      *   .addColumn('first_name', 'varchar(64)', col => col.notNull())
      *   .addColumn('last_name', 'varchar(64), col => col.notNull())
      *   .execute()
@@ -175,7 +175,7 @@ export declare class CreateTableBuilder<TB extends string, C extends string = ne
      * )
      * ```
      */
-    modifyFront(modifier: AnyRawBuilder): CreateTableBuilder<TB, C>;
+    modifyFront(modifier: Expression<any>): CreateTableBuilder<TB, C>;
     /**
      * This can be used to add any additional SQL to the end of the query.
      *
@@ -202,7 +202,40 @@ export declare class CreateTableBuilder<TB extends string, C extends string = ne
      * ) collate utf8_unicode_ci
      * ```
      */
-    modifyEnd(modifier: AnyRawBuilder): CreateTableBuilder<TB, C>;
+    modifyEnd(modifier: Expression<any>): CreateTableBuilder<TB, C>;
+    /**
+     * Calls the given function passing `this` as the only argument.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.schema
+     *   .createTable('test')
+     *   .call((builder) => builder.addColumn('id', 'integer'))
+     *   .execute()
+     * ```
+     *
+     * ```ts
+     * const addDefaultColumns = <T extends string, C extends string = never>(
+     *   builder: CreateTableBuilder<T, C>
+     * ) => {
+     *   return builder
+     *     .addColumn('id', 'integer', (col) => col.notNull())
+     *     .addColumn('created_at', 'date', (col) =>
+     *       col.notNull().defaultTo(sql`now()`)
+     *     )
+     *     .addColumn('updated_at', 'date', (col) =>
+     *       col.notNull().defaultTo(sql`now()`)
+     *     )
+     * }
+     *
+     * db.schema
+     *   .createTable('test')
+     *   .call(addDefaultColumns)
+     *   .execute()
+     * ```
+     */
+    call<T>(func: (qb: this) => T): T;
     toOperationNode(): CreateTableNode;
     compile(): CompiledQuery;
     execute(): Promise<void>;