kysely 0.19.12 → 0.21.0

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

@@ -32,6 +32,10 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
             !insert_query_node_js_1.InsertQueryNode.is(this.parentNode) &&
             !create_view_node_js_1.CreateViewNode.is(this.parentNode) &&
             !union_node_js_1.UnionNode.is(this.parentNode);
+        if (this.parentNode === undefined && node.explain) {
+            this.visitNode(node.explain);
+            this.append(' ');
+        }
         if (wrapInParens) {
             this.append('(');
         }
@@ -127,6 +131,10 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
     }
     visitInsertQuery(node) {
         const isSubQuery = this.nodeStack.find(query_node_js_1.QueryNode.is) !== node;
+        if (!isSubQuery && node.explain) {
+            this.visitNode(node.explain);
+            this.append(' ');
+        }
         if (isSubQuery) {
             this.append('(');
         }
@@ -171,6 +179,10 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
     }
     visitDeleteQuery(node) {
         const isSubQuery = this.nodeStack.find(query_node_js_1.QueryNode.is) !== node;
+        if (!isSubQuery && node.explain) {
+            this.visitNode(node.explain);
+            this.append(' ');
+        }
         if (isSubQuery) {
             this.append('(');
         }
@@ -227,7 +239,10 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
         this.append(this.getRightIdentifierWrapper());
     }
     compileUnwrappedIdentifier(node) {
-        this.append(this.sanitizeIdentifier(node.identifier));
+        if (!(0, object_utils_js_1.isString)(node.name)) {
+            throw new Error('a non-string identifier was passed to compileUnwrappedIdentifier.');
+        }
+        this.append(this.sanitizeIdentifier(node.name));
     }
     visitFilter(node) {
         if (node.left) {
@@ -303,14 +318,21 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
         this.append(node.operator);
     }
     visitTable(node) {
+        this.visitNode(node.table);
+    }
+    visitSchemableIdentifier(node) {
         if (node.schema) {
             this.visitNode(node.schema);
             this.append('.');
         }
-        this.visitNode(node.table);
+        this.visitNode(node.identifier);
     }
     visitCreateTable(node) {
         this.append('create ');
+        if (node.frontModifiers) {
+            this.compileList(node.frontModifiers, ' ');
+            this.append(' ');
+        }
         if (node.temporary) {
             this.append('temporary ');
         }
@@ -326,6 +348,10 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
             this.append(' on commit ');
             this.append(node.onCommit);
         }
+        if (node.endModifiers) {
+            this.append(' ');
+            this.compileList(node.endModifiers, ' ');
+        }
     }
     visitColumnDefinition(node) {
         this.visitNode(node.column);
@@ -412,6 +438,10 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
     }
     visitUpdateQuery(node) {
         const isSubQuery = this.nodeStack.find(query_node_js_1.QueryNode.is) !== node;
+        if (!isSubQuery && node.explain) {
+            this.visitNode(node.explain);
+            this.append(' ');
+        }
         if (isSubQuery) {
             this.append('(');
         }
@@ -806,6 +836,25 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
         }
         this.visitNode(node.name);
     }
+    visitExplain(node) {
+        this.append('explain');
+        if (node.options || node.format) {
+            this.append(' ');
+            this.append(this.getLeftExplainOptionsWrapper());
+            if (node.options) {
+                this.visitNode(node.options);
+                if (node.format) {
+                    this.append(this.getExplainOptionsDelimiter());
+                }
+            }
+            if (node.format) {
+                this.append('format');
+                this.append(this.getExplainOptionAssignment());
+                this.append(node.format);
+            }
+            this.append(this.getRightExplainOptionsWrapper());
+        }
+    }
     append(str) {
         this.#sql += str;
     }
@@ -822,10 +871,19 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
     getCurrentParameterPlaceholder() {
         return '$' + this.numParameters;
     }
+    getLeftExplainOptionsWrapper() {
+        return '(';
+    }
+    getExplainOptionAssignment() {
+        return ' ';
+    }
+    getExplainOptionsDelimiter() {
+        return ', ';
+    }
+    getRightExplainOptionsWrapper() {
+        return ')';
+    }
     sanitizeIdentifier(identifier) {
-        if (!(0, object_utils_js_1.isString)(identifier)) {
-            throw new Error('a non-string identifier was passed to sanitizeIdentifier.');
-        }
         const leftWrap = this.getLeftIdentifierWrapper();
         const rightWrap = this.getRightIdentifierWrapper();
         let sanitized = '';

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

@@ -1,5 +1,101 @@
 import { RawBuilder } from './raw-builder.js';
 export interface Sql {
+    /**
+     * Template tag for creating raw SQL snippets and queries.
+     *
+     * ```ts
+     * import { sql } from 'kysely'
+     *
+     * const id = 123
+     *
+     * const snippet = sql<Person[]>`select * from person where id = ${id}`
+     * ```
+     *
+     * Substitutions (the things inside `${}`) are automatically passed to the database
+     * as parameters and are NOT interpolated to the SQL string. There's no need to worry
+     * about SQL injection vulnerabilities.
+     *
+     * If you need your substitutions to be interpreted as identifiers, value literals or
+     * lists of things, see the {@link Sql.ref}, {@link Sql.table}, {@link Sql.id},
+     * {@link Sql.literal}, {@link Sql.raw} and {@link Sql.join} functions.
+     *
+     * You can pass sql snippets returned by the `sql` tag pretty much anywhere. Whenever
+     * something can't be done using the Kysely API, you should be able to drop down to
+     * raw SQL using the `sql` tag. Here's an example query that uses raw sql in a bunch
+     * of methods:
+     *
+     * ```ts
+     * const persons = await db
+     *   .selectFrom('person')
+     *   .select(
+     *     // If you use `sql` in a select statement, remember to call the `as`
+     *     // method to give it an alias. Otherwise Kysely is not able to add
+     *     // the column to the result type.
+     *     sql<string>`concat(first_name, ' ', last_name)`.as('full_name')
+     *   )
+     *   .where(sql`birthdate between ${date1} and ${date2}`)
+     *   // Here we assume we have list of nicknames for the person
+     *   // (a list of strings) and we use the PostgreSQL `@>` operator
+     *   // to test if all of them are valid nicknames for the user.
+     *   .where('nicknames', '@>', sql`ARRAY[${sql.join(nicknames)}]`)
+     *   .orderBy(sql`concat(first_name, ' ', last_name)`)
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select concat(first_name, ' ', last_name) as "full_name"
+     * from "person"
+     * where birthdate between $1 and $2
+     * and "nicknames" @> ARRAY[$3, $4, $5, $6, $7, $8, $9, $10]
+     * order by concat(first_name, ' ', last_name)
+     * ```
+     *
+     * SQL snippets can be executed by calling the `execute` method and passing a `Kysely`
+     * instance as the only argument:
+     *
+     * ```ts
+     * const result = await sql<Person[]>`select * from person`.execute(db)
+     * ```
+     *
+     * You can merge other `sql` expressions and queries using substitutions:
+     *
+     * ```ts
+     * const petName = db.selectFrom('pet').select('name').limit(1)
+     * const fullName = sql`concat(first_name, ' ', last_name)`
+     *
+     * sql`
+     *   select ${fullName} as full_name, ${petName} as pet_name
+     *   from person
+     * `
+     * ```
+     *
+     * Substitutions also handle {@link ExpressionBuilder.ref},
+     * {@link DynamicModule.ref} and pretty much anything else you
+     * throw at it. Here's an example of calling a function in a
+     * type-safe way:
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .select([
+     *     'first_name',
+     *     'last_name',
+     *     (eb) => {
+     *       // The `eb.ref` method is type-safe and only accepts
+     *       // column references that are possible.
+     *       const firstName = eb.ref('first_name')
+     *       const lastName = eb.ref('last_name')
+     *
+     *       const fullName = sql<string>`concat(${firstName}, ' ', ${lastName})`
+     *       return fullName.as('full_name')
+     *     }
+     *   ])
+     * ```
+     *
+     * don't know if that amount of ceremony is worth the small increase in
+     * type-safety though... But it's possible.
+     */
     <T = unknown>(sqlFragments: TemplateStringsArray, ...parameters: unknown[]): RawBuilder<T>;
     /**
      * This can be used to add runtime column references to SQL snippets.
@@ -232,100 +328,4 @@ export interface Sql {
      */
     join(array: unknown[], separator?: RawBuilder<any>): RawBuilder<unknown>;
 }
-/**
- * Template tag for creating raw SQL snippets and queries.
- *
- * ```ts
- * import { sql } from 'kysely'
- *
- * const id = 123
- *
- * const snippet = sql<Person[]>`select * from person where id = ${id}`
- * ```
- *
- * Substitutions (the things inside `${}`) are automatically passed to the database
- * as parameters and are NOT interpolated to the SQL string. There's no need to worry
- * about SQL injection vulnerabilities.
- *
- * If you need your substitutions to be interpreted as identifiers, value literals or
- * lists of things, see the {@link Sql.ref}, {@link Sql.table}, {@link Sql.id},
- * {@link Sql.literal}, {@link Sql.raw} and {@link Sql.join} functions.
- *
- * You can pass sql snippets returned by the `sql` tag pretty much anywhere. Whenever
- * something can't be done using the Kysely API, you should be able to drop down to
- * raw SQL using the `sql` tag. Here's an example query that uses raw sql in a bunch
- * of methods:
- *
- * ```ts
- * const persons = await db
- *   .selectFrom('person')
- *   .select(
- *     // If you use `sql` in a select statement, remember to call the `as`
- *     // method to give it an alias. Otherwise Kysely is not able to add
- *     // the column to the result type.
- *     sql<string>`concat(first_name, ' ', last_name)`.as('full_name')
- *   )
- *   .where(sql`birthdate between ${date1} and ${date2}`)
- *   // Here we assume we have list of nicknames for the person
- *   // (a list of strings) and we use the PostgreSQL `@>` operator
- *   // to test if all of them are valid nicknames for the user.
- *   .where('nicknames', '@>', sql`ARRAY[${sql.join(nicknames)}]`)
- *   .orderBy(sql`concat(first_name, ' ', last_name)`)
- *   .execute()
- * ```
- *
- * The generated SQL (PostgreSQL):
- *
- * ```sql
- * select concat(first_name, ' ', last_name) as "full_name"
- * from "person"
- * where birthdate between $1 and $2
- * and "nicknames" @> ARRAY[$3, $4, $5, $6, $7, $8, $9, $10]
- * order by concat(first_name, ' ', last_name)
- * ```
- *
- * SQL snippets can be executed by calling the `execute` method and passing a `Kysely`
- * instance as the only argument:
- *
- * ```ts
- * const result = await sql<Person[]>`select * from person`.execute(db)
- * ```
- *
- * You can merge other `sql` expressions and queries using substitutions:
- *
- * ```ts
- * const petName = db.selectFrom('pet').select('name').limit(1)
- * const fullName = sql`concat(first_name, ' ', last_name)`
- *
- * sql`
- *   select ${fullName} as full_name, ${petName} as pet_name
- *   from person
- * `
- * ```
- *
- * Substitutions also handle {@link ExpressionBuilder.ref},
- * {@link DynamicModule.ref} and pretty much anything else you
- * throw at it. Here's an example of calling a function in a
- * type-safe way:
- *
- * ```ts
- * db.selectFrom('person')
- *   .select([
- *     'first_name',
- *     'last_name',
- *     (eb) => {
- *       // The `eb.ref` method is type-safe and only accepts
- *       // column references that are possible.
- *       const firstName = eb.ref('first_name')
- *       const lastName = eb.ref('last_name')
- *
- *       const fullName = sql<string>`concat(${firstName}, ' ', ${lastName})`
- *       return fullName.as('full_name')
- *     }
- *   ])
- * ```
- *
- * don't know if that amount of ceremony is worth the small increase in
- * type-safety though... But it's possible.
- */
 export declare const sql: Sql;

package/dist/cjs/raw-builder/sql.js

@@ -9,102 +9,6 @@ const table_parser_js_1 = require("../parser/table-parser.js");
 const value_parser_js_1 = require("../parser/value-parser.js");
 const query_id_js_1 = require("../util/query-id.js");
 const raw_builder_js_1 = require("./raw-builder.js");
-/**
- * Template tag for creating raw SQL snippets and queries.
- *
- * ```ts
- * import { sql } from 'kysely'
- *
- * const id = 123
- *
- * const snippet = sql<Person[]>`select * from person where id = ${id}`
- * ```
- *
- * Substitutions (the things inside `${}`) are automatically passed to the database
- * as parameters and are NOT interpolated to the SQL string. There's no need to worry
- * about SQL injection vulnerabilities.
- *
- * If you need your substitutions to be interpreted as identifiers, value literals or
- * lists of things, see the {@link Sql.ref}, {@link Sql.table}, {@link Sql.id},
- * {@link Sql.literal}, {@link Sql.raw} and {@link Sql.join} functions.
- *
- * You can pass sql snippets returned by the `sql` tag pretty much anywhere. Whenever
- * something can't be done using the Kysely API, you should be able to drop down to
- * raw SQL using the `sql` tag. Here's an example query that uses raw sql in a bunch
- * of methods:
- *
- * ```ts
- * const persons = await db
- *   .selectFrom('person')
- *   .select(
- *     // If you use `sql` in a select statement, remember to call the `as`
- *     // method to give it an alias. Otherwise Kysely is not able to add
- *     // the column to the result type.
- *     sql<string>`concat(first_name, ' ', last_name)`.as('full_name')
- *   )
- *   .where(sql`birthdate between ${date1} and ${date2}`)
- *   // Here we assume we have list of nicknames for the person
- *   // (a list of strings) and we use the PostgreSQL `@>` operator
- *   // to test if all of them are valid nicknames for the user.
- *   .where('nicknames', '@>', sql`ARRAY[${sql.join(nicknames)}]`)
- *   .orderBy(sql`concat(first_name, ' ', last_name)`)
- *   .execute()
- * ```
- *
- * The generated SQL (PostgreSQL):
- *
- * ```sql
- * select concat(first_name, ' ', last_name) as "full_name"
- * from "person"
- * where birthdate between $1 and $2
- * and "nicknames" @> ARRAY[$3, $4, $5, $6, $7, $8, $9, $10]
- * order by concat(first_name, ' ', last_name)
- * ```
- *
- * SQL snippets can be executed by calling the `execute` method and passing a `Kysely`
- * instance as the only argument:
- *
- * ```ts
- * const result = await sql<Person[]>`select * from person`.execute(db)
- * ```
- *
- * You can merge other `sql` expressions and queries using substitutions:
- *
- * ```ts
- * const petName = db.selectFrom('pet').select('name').limit(1)
- * const fullName = sql`concat(first_name, ' ', last_name)`
- *
- * sql`
- *   select ${fullName} as full_name, ${petName} as pet_name
- *   from person
- * `
- * ```
- *
- * Substitutions also handle {@link ExpressionBuilder.ref},
- * {@link DynamicModule.ref} and pretty much anything else you
- * throw at it. Here's an example of calling a function in a
- * type-safe way:
- *
- * ```ts
- * db.selectFrom('person')
- *   .select([
- *     'first_name',
- *     'last_name',
- *     (eb) => {
- *       // The `eb.ref` method is type-safe and only accepts
- *       // column references that are possible.
- *       const firstName = eb.ref('first_name')
- *       const lastName = eb.ref('last_name')
- *
- *       const fullName = sql<string>`concat(${firstName}, ' ', ${lastName})`
- *       return fullName.as('full_name')
- *     }
- *   ])
- * ```
- *
- * don't know if that amount of ceremony is worth the small increase in
- * type-safety though... But it's possible.
- */
 exports.sql = Object.assign((sqlFragments, ...parameters) => {
     return new raw_builder_js_1.RawBuilder({
         queryId: (0, query_id_js_1.createQueryId)(),

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

@@ -92,7 +92,7 @@ export declare class AlterTableAddColumnBuilder implements ColumnDefinitionBuild
      * Makes the column the primary key.
      *
      * If you want to specify a composite primary key use the
-     * {@link TableBuilder.addPrimaryKeyConstraint} method.
+     * {@link CreateTableBuilder.addPrimaryKeyConstraint} method.
      */
     primaryKey(): AlterTableAddColumnBuilder;
     /**
@@ -100,7 +100,7 @@ export declare class AlterTableAddColumnBuilder implements ColumnDefinitionBuild
      *
      * 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 TableBuilder.addForeignKeyConstraint} method instead.
+     * {@link CreateTableBuilder.addForeignKeyConstraint} method instead.
      *
      * ### Examples
      *
@@ -114,7 +114,7 @@ export declare class AlterTableAddColumnBuilder implements ColumnDefinitionBuild
      *
      * 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 TableBuilder.addForeignKeyConstraint} method instead.
+     * {@link CreateTableBuilder.addForeignKeyConstraint} method instead.
      *
      * ### Examples
      *
@@ -258,7 +258,7 @@ export declare class AlterTableModifyColumnBuilder implements ColumnDefinitionBu
      * Makes the column the primary key.
      *
      * If you want to specify a composite primary key use the
-     * {@link TableBuilder.addPrimaryKeyConstraint} method.
+     * {@link CreateTableBuilder.addPrimaryKeyConstraint} method.
      */
     primaryKey(): AlterTableModifyColumnBuilder;
     /**
@@ -266,7 +266,7 @@ export declare class AlterTableModifyColumnBuilder implements ColumnDefinitionBu
      *
      * 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 TableBuilder.addForeignKeyConstraint} method instead.
+     * {@link CreateTableBuilder.addForeignKeyConstraint} method instead.
      *
      * ### Examples
      *
@@ -280,7 +280,7 @@ export declare class AlterTableModifyColumnBuilder implements ColumnDefinitionBu
      *
      * 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 TableBuilder.addForeignKeyConstraint} method instead.
+     * {@link CreateTableBuilder.addForeignKeyConstraint} method instead.
      *
      * ### Examples
      *

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

@@ -16,7 +16,7 @@ export interface ColumnDefinitionBuilderInterface {
      * Makes the column the primary key.
      *
      * If you want to specify a composite primary key use the
-     * {@link TableBuilder.addPrimaryKeyConstraint} method.
+     * {@link CreateTableBuilder.addPrimaryKeyConstraint} method.
      */
     primaryKey(): ColumnDefinitionBuilderInterface;
     /**
@@ -24,7 +24,7 @@ export interface ColumnDefinitionBuilderInterface {
      *
      * 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 TableBuilder.addForeignKeyConstraint} method instead.
+     * {@link CreateTableBuilder.addForeignKeyConstraint} method instead.
      *
      * ### Examples
      *
@@ -38,7 +38,7 @@ export interface ColumnDefinitionBuilderInterface {
      *
      * 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 TableBuilder.addForeignKeyConstraint} method instead.
+     * {@link CreateTableBuilder.addForeignKeyConstraint} method instead.
      *
      * ### Examples
      *
@@ -175,7 +175,7 @@ export declare class ColumnDefinitionBuilder implements ColumnDefinitionBuilderI
      * Makes the column the primary key.
      *
      * If you want to specify a composite primary key use the
-     * {@link TableBuilder.addPrimaryKeyConstraint} method.
+     * {@link CreateTableBuilder.addPrimaryKeyConstraint} method.
      */
     primaryKey(): ColumnDefinitionBuilder;
     /**
@@ -183,7 +183,7 @@ export declare class ColumnDefinitionBuilder implements ColumnDefinitionBuilderI
      *
      * 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 TableBuilder.addForeignKeyConstraint} method instead.
+     * {@link CreateTableBuilder.addForeignKeyConstraint} method instead.
      *
      * ### Examples
      *
@@ -197,7 +197,7 @@ export declare class ColumnDefinitionBuilder implements ColumnDefinitionBuilderI
      *
      * 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 TableBuilder.addForeignKeyConstraint} method instead.
+     * {@link CreateTableBuilder.addForeignKeyConstraint} method instead.
      *
      * ### Examples
      *

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

@@ -149,6 +149,60 @@ export declare class CreateTableBuilder<TB extends string, C extends string = ne
      * ```
      */
     addForeignKeyConstraint(constraintName: string, columns: C[], targetTable: string, targetColumns: string[], build?: ForeignKeyConstraintBuilderCallback): CreateTableBuilder<TB, C>;
+    /**
+     * This can be used to add any additional SQL to the front of the query __after__ the `create` keyword.
+     *
+     * Also see {@link temporary}.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.schema.createTable('person')
+     *   .modifyFront(sql`global temporary`)
+     *   .addColumn('id', 'integer', col => col => primaryKey())
+     *   .addColumn('first_name', 'varchar(64)', col => col.notNull())
+     *   .addColumn('last_name', 'varchar(64), col => col.notNull())
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (Postgres):
+     *
+     * ```sql
+     * create global temporary table "person" (
+     *   "id" integer primary key,
+     *   "first_name" varchar(64) not null,
+     *   "last_name" varchar(64) not null
+     * )
+     * ```
+     */
+    modifyFront(modifier: AnyRawBuilder): CreateTableBuilder<TB, C>;
+    /**
+     * This can be used to add any additional SQL to the end of the query.
+     *
+     * Also see {@link onCommit}.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.schema.createTable('person')
+     *   .addColumn('id', 'integer', col => col => primaryKey())
+     *   .addColumn('first_name', 'varchar(64)', col => col.notNull())
+     *   .addColumn('last_name', 'varchar(64), col => col.notNull())
+     *   .modifyEnd(sql`collate utf8_unicode_ci`)
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * create table `person` (
+     *   `id` integer primary key,
+     *   `first_name` varchar(64) not null,
+     *   `last_name` varchar(64) not null
+     * ) collate utf8_unicode_ci
+     * ```
+     */
+    modifyEnd(modifier: AnyRawBuilder): CreateTableBuilder<TB, C>;
     toOperationNode(): CreateTableNode;
     compile(): CompiledQuery;
     execute(): Promise<void>;

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

@@ -206,6 +206,70 @@ class CreateTableBuilder {
             createTableNode: create_table_node_js_1.CreateTableNode.cloneWithConstraint(this.#props.createTableNode, builder.toOperationNode()),
         });
     }
+    /**
+     * This can be used to add any additional SQL to the front of the query __after__ the `create` keyword.
+     *
+     * Also see {@link temporary}.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.schema.createTable('person')
+     *   .modifyFront(sql`global temporary`)
+     *   .addColumn('id', 'integer', col => col => primaryKey())
+     *   .addColumn('first_name', 'varchar(64)', col => col.notNull())
+     *   .addColumn('last_name', 'varchar(64), col => col.notNull())
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (Postgres):
+     *
+     * ```sql
+     * create global temporary table "person" (
+     *   "id" integer primary key,
+     *   "first_name" varchar(64) not null,
+     *   "last_name" varchar(64) not null
+     * )
+     * ```
+     */
+    modifyFront(modifier) {
+        return new CreateTableBuilder({
+            ...this.#props,
+            createTableNode: create_table_node_js_1.CreateTableNode.cloneWithFrontModifier(this.#props.createTableNode, modifier.toOperationNode()),
+        });
+    }
+    /**
+     * This can be used to add any additional SQL to the end of the query.
+     *
+     * Also see {@link onCommit}.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.schema.createTable('person')
+     *   .addColumn('id', 'integer', col => col => primaryKey())
+     *   .addColumn('first_name', 'varchar(64)', col => col.notNull())
+     *   .addColumn('last_name', 'varchar(64), col => col.notNull())
+     *   .modifyEnd(sql`collate utf8_unicode_ci`)
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * create table `person` (
+     *   `id` integer primary key,
+     *   `first_name` varchar(64) not null,
+     *   `last_name` varchar(64) not null
+     * ) collate utf8_unicode_ci
+     * ```
+     */
+    modifyEnd(modifier) {
+        return new CreateTableBuilder({
+            ...this.#props,
+            createTableNode: create_table_node_js_1.CreateTableNode.cloneWithEndModifier(this.#props.createTableNode, modifier.toOperationNode()),
+        });
+    }
     toOperationNode() {
         return this.#props.executor.transformQuery(this.#props.createTableNode, this.#props.queryId);
     }

package/dist/cjs/util/explainable.d.ts

@@ -0,0 +1,5 @@
+import { AnyRawBuilder } from './type-utils.js';
+export declare type ExplainFormat = 'text' | 'xml' | 'json' | 'yaml' | 'traditional' | 'tree';
+export interface Explainable {
+    explain<O extends Record<string, any> = Record<string, any>>(format?: ExplainFormat, options?: AnyRawBuilder): Promise<O[]>;
+}

package/dist/cjs/util/explainable.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });