kysely 0.19.12 → 0.20.0

package/dist/esm/operation-node/operation-node.d.ts

@@ -1,4 +1,4 @@
-export declare type OperationNodeKind = 'IdentifierNode' | 'RawNode' | 'SelectQueryNode' | 'SelectionNode' | 'ReferenceNode' | 'ColumnNode' | 'TableNode' | 'AliasNode' | 'FromNode' | 'SelectAllNode' | 'FilterNode' | 'AndNode' | 'OrNode' | 'ParensNode' | 'ValueNode' | 'ValueListNode' | 'PrimitiveValueListNode' | 'JoinNode' | 'OperatorNode' | 'WhereNode' | 'InsertQueryNode' | 'DeleteQueryNode' | 'ReturningNode' | 'CreateTableNode' | 'ColumnDefinitionNode' | 'AddColumnNode' | 'DropTableNode' | 'DataTypeNode' | 'OrderByNode' | 'OrderByItemNode' | 'GroupByNode' | 'GroupByItemNode' | 'UpdateQueryNode' | 'ColumnUpdateNode' | 'LimitNode' | 'OffsetNode' | 'OnConflictNode' | 'OnDuplicateKeyNode' | 'CreateIndexNode' | 'DropIndexNode' | 'ListNode' | 'ReferencesNode' | 'PrimaryKeyConstraintNode' | 'UniqueConstraintNode' | 'CheckConstraintNode' | 'ForeignKeyConstraintNode' | 'WithNode' | 'CommonTableExpressionNode' | 'HavingNode' | 'CreateSchemaNode' | 'DropSchemaNode' | 'AlterTableNode' | 'ModifyColumnNode' | 'DropColumnNode' | 'RenameColumnNode' | 'AlterColumnNode' | 'AddConstraintNode' | 'DropConstraintNode' | 'UnionNode' | 'CreateViewNode' | 'DropViewNode' | 'GeneratedNode' | 'DefaultValueNode' | 'OnNode' | 'ValuesNode' | 'CommonTableExpressionNameNode' | 'SelectModifierNode' | 'CreateTypeNode' | 'DropTypeNode';
+export declare type OperationNodeKind = 'IdentifierNode' | 'RawNode' | 'SelectQueryNode' | 'SelectionNode' | 'ReferenceNode' | 'ColumnNode' | 'TableNode' | 'AliasNode' | 'FromNode' | 'SelectAllNode' | 'FilterNode' | 'AndNode' | 'OrNode' | 'ParensNode' | 'ValueNode' | 'ValueListNode' | 'PrimitiveValueListNode' | 'JoinNode' | 'OperatorNode' | 'WhereNode' | 'InsertQueryNode' | 'DeleteQueryNode' | 'ReturningNode' | 'CreateTableNode' | 'ColumnDefinitionNode' | 'AddColumnNode' | 'DropTableNode' | 'DataTypeNode' | 'OrderByNode' | 'OrderByItemNode' | 'GroupByNode' | 'GroupByItemNode' | 'UpdateQueryNode' | 'ColumnUpdateNode' | 'LimitNode' | 'OffsetNode' | 'OnConflictNode' | 'OnDuplicateKeyNode' | 'CreateIndexNode' | 'DropIndexNode' | 'ListNode' | 'ReferencesNode' | 'PrimaryKeyConstraintNode' | 'UniqueConstraintNode' | 'CheckConstraintNode' | 'ForeignKeyConstraintNode' | 'WithNode' | 'CommonTableExpressionNode' | 'HavingNode' | 'CreateSchemaNode' | 'DropSchemaNode' | 'AlterTableNode' | 'ModifyColumnNode' | 'DropColumnNode' | 'RenameColumnNode' | 'AlterColumnNode' | 'AddConstraintNode' | 'DropConstraintNode' | 'UnionNode' | 'CreateViewNode' | 'DropViewNode' | 'GeneratedNode' | 'DefaultValueNode' | 'OnNode' | 'ValuesNode' | 'CommonTableExpressionNameNode' | 'SelectModifierNode' | 'CreateTypeNode' | 'DropTypeNode' | 'ExplainNode';
 export interface OperationNode {
     readonly kind: OperationNodeKind;
 }

package/dist/esm/operation-node/select-query-node.d.ts

@@ -14,6 +14,7 @@ import { WhereNode } from './where-node.js';
 import { WithNode } from './with-node.js';
 import { UnionNode } from './union-node.js';
 import { SelectModifierNode } from './select-modifier-node.js';
+import { ExplainNode } from './explain-node.js';
 export interface SelectQueryNode extends OperationNode {
     readonly kind: 'SelectQueryNode';
     readonly from: FromNode;
@@ -30,6 +31,7 @@ export interface SelectQueryNode extends OperationNode {
     readonly with?: WithNode;
     readonly having?: HavingNode;
     readonly union?: ReadonlyArray<UnionNode>;
+    readonly explain?: ExplainNode;
 }
 /**
  * @internal
@@ -48,4 +50,5 @@ export declare const SelectQueryNode: Readonly<{
     cloneWithHaving(selectNode: SelectQueryNode, filter: FilterExpressionNode): SelectQueryNode;
     cloneWithOrHaving(selectNode: SelectQueryNode, filter: FilterExpressionNode): SelectQueryNode;
     cloneWithUnion(selectNode: SelectQueryNode, union: UnionNode): SelectQueryNode;
+    cloneWithExplain(selectNode: SelectQueryNode, explain: ExplainNode): SelectQueryNode;
 }>;

package/dist/esm/operation-node/select-query-node.js

@@ -102,4 +102,10 @@ export const SelectQueryNode = freeze({
                 : freeze([union]),
         });
     },
+    cloneWithExplain(selectNode, explain) {
+        return freeze({
+            ...selectNode,
+            explain,
+        });
+    },
 });

package/dist/esm/operation-node/update-query-node.d.ts

@@ -8,6 +8,7 @@ import { ValueListNode } from './value-list-node.js';
 import { WhereNode } from './where-node.js';
 import { WithNode } from './with-node.js';
 import { FromNode } from './from-node.js';
+import { ExplainNode } from './explain-node.js';
 export declare type UpdateValuesNode = ValueListNode | PrimitiveValueListNode;
 export interface UpdateQueryNode extends OperationNode {
     readonly kind: 'UpdateQueryNode';
@@ -18,6 +19,7 @@ export interface UpdateQueryNode extends OperationNode {
     readonly updates?: ReadonlyArray<ColumnUpdateNode>;
     readonly returning?: ReturningNode;
     readonly with?: WithNode;
+    readonly explain?: ExplainNode;
 }
 /**
  * @internal
@@ -27,4 +29,5 @@ export declare const UpdateQueryNode: Readonly<{
     create(table: TableExpressionNode, withNode?: WithNode): UpdateQueryNode;
     cloneWithFromItems(updateQuery: UpdateQueryNode, fromItems: ReadonlyArray<TableExpressionNode>): UpdateQueryNode;
     cloneWithUpdates(updateQuery: UpdateQueryNode, updates: ReadonlyArray<ColumnUpdateNode>): UpdateQueryNode;
+    cloneWithExplain(updateQuery: UpdateQueryNode, explain: ExplainNode): UpdateQueryNode;
 }>;

package/dist/esm/operation-node/update-query-node.js

@@ -31,4 +31,10 @@ export const UpdateQueryNode = freeze({
                 : updates,
         });
     },
+    cloneWithExplain(updateQuery, explain) {
+        return freeze({
+            ...updateQuery,
+            explain,
+        });
+    },
 });

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

@@ -20,7 +20,8 @@ import { Selectable } from '../util/column-type.js';
 import { OrderByDirectionExpression, OrderByExpression } from '../parser/order-by-parser.js';
 import { AliasedQueryBuilder } from './select-query-builder.js';
 import { AliasedRawBuilder } from '../raw-builder/raw-builder.js';
-export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements WhereInterface<DB, TB>, ReturningInterface<DB, TB, O>, OperationNodeSource, Compilable {
+import { Explainable, ExplainFormat } from '../util/explainable.js';
+export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements WhereInterface<DB, TB>, ReturningInterface<DB, TB, O>, OperationNodeSource, Compilable, Explainable {
     #private;
     constructor(props: DeleteQueryBuilderProps);
     /**
@@ -744,6 +745,23 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * error.
      */
     executeTakeFirstOrThrow(errorConstructor?: NoResultErrorConstructor): Promise<O>;
+    /**
+     * Executes query with `explain` statement before `delete` keyword.
+     *
+     * ```ts
+     * const explained = await db
+     *  .deleteFrom('person')
+     *  .where('id', '=', 123)
+     *  .explain('json')
+     * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * explain format=json delete from `person` where `id` = ?
+     * ```
+     */
+    explain<ER extends Record<string, any> = Record<string, any>>(format?: ExplainFormat, options?: AnyRawBuilder): Promise<ER[]>;
 }
 export interface DeleteQueryBuilderProps {
     readonly queryId: QueryId;

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

@@ -10,6 +10,7 @@ import { DeleteResult } from './delete-result.js';
 import { DeleteQueryNode } from '../operation-node/delete-query-node.js';
 import { LimitNode } from '../operation-node/limit-node.js';
 import { parseOrderBy, } from '../parser/order-by-parser.js';
+import { ExplainNode } from '../operation-node/explain-node.js';
 export class DeleteQueryBuilder {
     #props;
     constructor(props) {
@@ -293,5 +294,28 @@ export class DeleteQueryBuilder {
         }
         return result;
     }
+    /**
+     * Executes query with `explain` statement before `delete` keyword.
+     *
+     * ```ts
+     * const explained = await db
+     *  .deleteFrom('person')
+     *  .where('id', '=', 123)
+     *  .explain('json')
+     * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * explain format=json delete from `person` where `id` = ?
+     * ```
+     */
+    async explain(format, options) {
+        const builder = new DeleteQueryBuilder({
+            ...this.#props,
+            queryNode: DeleteQueryNode.cloneWithExplain(this.#props.queryNode, ExplainNode.create(format, options)),
+        });
+        return await builder.execute();
+    }
 }
 preventAwait(DeleteQueryBuilder, "don't await DeleteQueryBuilder instances directly. To execute the query you need to call `execute` or `executeTakeFirst`.");

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

@@ -85,7 +85,7 @@ export declare class FunctionBuilder<DB, TB extends keyof DB> {
      *   .execute()
      * ```
      */
-    avg<O extends number | string, C extends StringReference<DB, TB> = any>(column: C): RawBuilder<O>;
+    avg<O extends number | string, C extends StringReference<DB, TB> = StringReference<DB, TB>>(column: C): RawBuilder<O>;
     /**
      * Calls the `sum` function for the column given as the argument.
      *
@@ -107,7 +107,7 @@ export declare class FunctionBuilder<DB, TB extends keyof DB> {
      *   .execute()
      * ```
      */
-    sum<O extends number | string | bigint, C extends StringReference<DB, TB> = any>(column: C): RawBuilder<O>;
+    sum<O extends number | string | bigint, C extends StringReference<DB, TB> = StringReference<DB, TB>>(column: C): RawBuilder<O>;
     /**
      * Calls the `count` function for the column given as the argument.
      *
@@ -129,5 +129,5 @@ export declare class FunctionBuilder<DB, TB extends keyof DB> {
      *   .execute()
      * ```
      */
-    count<O extends number | string | bigint, C extends StringReference<DB, TB> = any>(column: C): RawBuilder<O>;
+    count<O extends number | string | bigint, C extends StringReference<DB, TB> = StringReference<DB, TB>>(column: C): RawBuilder<O>;
 }

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

@@ -3,7 +3,7 @@ import { CompiledQuery } from '../query-compiler/compiled-query.js';
 import { SelectExpression } from '../parser/select-parser.js';
 import { InsertObject } from '../parser/insert-values-parser.js';
 import { InsertQueryNode } from '../operation-node/insert-query-node.js';
-import { MergePartial, SingleResultType } from '../util/type-utils.js';
+import { AnyRawBuilder, MergePartial, SingleResultType } from '../util/type-utils.js';
 import { MutationObject } from '../parser/update-set-parser.js';
 import { Compilable } from '../util/compilable.js';
 import { QueryExecutor } from '../query-executor/query-executor.js';
@@ -16,7 +16,8 @@ import { ComplexExpression } from '../parser/complex-expression-parser.js';
 import { ReturningInterface } from './returning-interface.js';
 import { OnConflictBuilder, OnConflictDoNothingBuilder, OnConflictUpdateBuilder } from './on-conflict-builder.js';
 import { Selectable } from '../util/column-type.js';
-export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements ReturningInterface<DB, TB, O>, OperationNodeSource, Compilable {
+import { Explainable, ExplainFormat } from '../util/explainable.js';
+export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements ReturningInterface<DB, TB, O>, OperationNodeSource, Compilable, Explainable {
     #private;
     constructor(props: InsertQueryBuilderProps);
     /**
@@ -541,6 +542,23 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      * error.
      */
     executeTakeFirstOrThrow(errorConstructor?: NoResultErrorConstructor): Promise<O>;
+    /**
+     * Executes query with `explain` statement before `insert` keyword.
+     *
+     * ```ts
+     * const explained = await db
+     *  .insertInto('person')
+     *  .values(values)
+     *  .explain('json')
+     * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * explain format=json insert into `person` (`id`, `first_name`, `last_name`) values (?, ?, ?) (?, ?, ?)
+     * ```
+     */
+    explain<ER extends Record<string, any> = Record<string, any>>(format?: ExplainFormat, options?: AnyRawBuilder): Promise<ER[]>;
 }
 export interface InsertQueryBuilderProps {
     readonly queryId: QueryId;

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

@@ -13,6 +13,7 @@ import { parseComplexExpression, } from '../parser/complex-expression-parser.js'
 import { ColumnNode } from '../operation-node/column-node.js';
 import { OnConflictBuilder, } from './on-conflict-builder.js';
 import { OnConflictNode } from '../operation-node/on-conflict-node.js';
+import { ExplainNode } from '../operation-node/explain-node.js';
 export class InsertQueryBuilder {
     #props;
     constructor(props) {
@@ -444,5 +445,30 @@ export class InsertQueryBuilder {
         }
         return result;
     }
+    /**
+     * Executes query with `explain` statement before `insert` keyword.
+     *
+     * ```ts
+     * const explained = await db
+     *  .insertInto('person')
+     *  .values(values)
+     *  .explain('json')
+     * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * explain format=json insert into `person` (`id`, `first_name`, `last_name`) values (?, ?, ?) (?, ?, ?)
+     * ```
+     */
+    async explain(format, options) {
+        const builder = new InsertQueryBuilder({
+            ...this.#props,
+            queryNode: InsertQueryNode.cloneWith(this.#props.queryNode, {
+                explain: ExplainNode.create(format, options),
+            }),
+        });
+        return await builder.execute();
+    }
 }
 preventAwait(InsertQueryBuilder, "don't await InsertQueryBuilder instances directly. To execute the query you need to call `execute` or `executeTakeFirst`.");

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

@@ -18,7 +18,8 @@ import { WhereInterface } from './where-interface.js';
 import { NoResultErrorConstructor } from './no-result-error.js';
 import { HavingInterface } from './having-interface.js';
 import { AliasedRawBuilder } from '../raw-builder/raw-builder.js';
-export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements WhereInterface<DB, TB>, HavingInterface<DB, TB>, OperationNodeSource, Compilable {
+import { Explainable, ExplainFormat } from '../util/explainable.js';
+export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements WhereInterface<DB, TB>, HavingInterface<DB, TB>, OperationNodeSource, Compilable, Explainable {
     #private;
     constructor(props: SelectQueryBuilderProps);
     /**
@@ -1370,6 +1371,42 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      * ```
      */
     stream(chunkSize?: number): AsyncIterableIterator<O>;
+    /**
+     * Executes query with `explain` statement before `select` keyword.
+     *
+     * ```ts
+     * const explained = await db
+     *  .selectFrom('person')
+     *  .where('gender', '=', 'female')
+     *  .selectAll()
+     *  .explain('json')
+     * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * explain format=json select * from `person` where `gender` = ?
+     * ```
+     *
+     * You can also execute `explain analyze` statements.
+     *
+     * ```ts
+     * import { sql } from 'kysely'
+     *
+     * const explained = await db
+     *  .selectFrom('person')
+     *  .where('gender', '=', 'female')
+     *  .selectAll()
+     *  .explain('json', sql`analyze`)
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * explain (analyze, format json) select * from "person" where "gender" = $1
+     * ```
+     */
+    explain<ER extends Record<string, any> = Record<string, any>>(format?: ExplainFormat, options?: AnyRawBuilder): Promise<ER[]>;
 }
 export interface SelectQueryBuilderProps {
     readonly queryId: QueryId;

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

@@ -15,6 +15,7 @@ import { parseGroupBy } from '../parser/group-by-parser.js';
 import { parseUnion } from '../parser/union-parser.js';
 import { NoResultError } from './no-result-error.js';
 import { IdentifierNode } from '../operation-node/identifier-node.js';
+import { ExplainNode } from '../operation-node/explain-node.js';
 export class SelectQueryBuilder {
     #props;
     constructor(props) {
@@ -627,8 +628,8 @@ export class SelectQueryBuilder {
      * Also see the {@link executeTakeFirst} and {@link executeTakeFirstOrThrow} methods.
      */
     async execute() {
-        const compildQuery = this.compile();
-        const result = await this.#props.executor.executeQuery(compildQuery, this.#props.queryId);
+        const compiledQuery = this.compile();
+        const result = await this.#props.executor.executeQuery(compiledQuery, this.#props.queryId);
         return result.rows;
     }
     /**
@@ -687,6 +688,48 @@ export class SelectQueryBuilder {
             yield* item.rows;
         }
     }
+    /**
+     * Executes query with `explain` statement before `select` keyword.
+     *
+     * ```ts
+     * const explained = await db
+     *  .selectFrom('person')
+     *  .where('gender', '=', 'female')
+     *  .selectAll()
+     *  .explain('json')
+     * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * explain format=json select * from `person` where `gender` = ?
+     * ```
+     *
+     * You can also execute `explain analyze` statements.
+     *
+     * ```ts
+     * import { sql } from 'kysely'
+     *
+     * const explained = await db
+     *  .selectFrom('person')
+     *  .where('gender', '=', 'female')
+     *  .selectAll()
+     *  .explain('json', sql`analyze`)
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * explain (analyze, format json) select * from "person" where "gender" = $1
+     * ```
+     */
+    async explain(format, options) {
+        const builder = new SelectQueryBuilder({
+            ...this.#props,
+            queryNode: SelectQueryNode.cloneWithExplain(this.#props.queryNode, ExplainNode.create(format, options)),
+        });
+        return await builder.execute();
+    }
 }
 preventAwait(SelectQueryBuilder, "don't await SelectQueryBuilder instances directly. To execute the query you need to call `execute` or `executeTakeFirst`.");
 /**

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

@@ -20,7 +20,8 @@ import { NoResultErrorConstructor } from './no-result-error.js';
 import { Selectable } from '../util/column-type.js';
 import { AliasedQueryBuilder } from './select-query-builder.js';
 import { AliasedRawBuilder } from '../raw-builder/raw-builder.js';
-export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyof DB, O> implements WhereInterface<DB, TB>, ReturningInterface<DB, TB, O>, OperationNodeSource, Compilable {
+import { Explainable, ExplainFormat } from '../util/explainable.js';
+export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyof DB, O> implements WhereInterface<DB, TB>, ReturningInterface<DB, TB, O>, OperationNodeSource, Compilable, Explainable {
     #private;
     constructor(props: UpdateQueryBuilderProps);
     /**
@@ -809,6 +810,24 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      * error.
      */
     executeTakeFirstOrThrow(errorConstructor?: NoResultErrorConstructor): Promise<O>;
+    /**
+     * Executes query with `explain` statement before `update` keyword.
+     *
+     * ```ts
+     * const explained = await db
+     *  .updateTable('person')
+     *  .set(updates)
+     *  .where('id', '=', 123)
+     *  .explain('json')
+     * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * explain format=json update `person` set `first_name` = ?, `last_name` = ? where `id` = ?
+     * ```
+     */
+    explain<ER extends Record<string, any> = Record<string, any>>(format?: ExplainFormat, options?: AnyRawBuilder): Promise<ER[]>;
 }
 export interface UpdateQueryBuilderProps {
     readonly queryId: QueryId;

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

@@ -10,6 +10,7 @@ import { preventAwait } from '../util/prevent-await.js';
 import { freeze } from '../util/object-utils.js';
 import { UpdateResult } from './update-result.js';
 import { NoResultError } from './no-result-error.js';
+import { ExplainNode } from '../operation-node/explain-node.js';
 export class UpdateQueryBuilder {
     #props;
     constructor(props) {
@@ -330,5 +331,29 @@ export class UpdateQueryBuilder {
         }
         return result;
     }
+    /**
+     * Executes query with `explain` statement before `update` keyword.
+     *
+     * ```ts
+     * const explained = await db
+     *  .updateTable('person')
+     *  .set(updates)
+     *  .where('id', '=', 123)
+     *  .explain('json')
+     * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * explain format=json update `person` set `first_name` = ?, `last_name` = ? where `id` = ?
+     * ```
+     */
+    async explain(format, options) {
+        const builder = new UpdateQueryBuilder({
+            ...this.#props,
+            queryNode: UpdateQueryNode.cloneWithExplain(this.#props.queryNode, ExplainNode.create(format, options)),
+        });
+        return await builder.execute();
+    }
 }
 preventAwait(UpdateQueryBuilder, "don't await UpdateQueryBuilder instances directly. To execute the query you need to call `execute` or `executeTakeFirst`.");

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

@@ -71,6 +71,7 @@ import { CommonTableExpressionNameNode } from '../operation-node/common-table-ex
 import { SelectModifierNode } from '../operation-node/select-modifier-node.js';
 import { CreateTypeNode } from '../operation-node/create-type-node.js';
 import { DropTypeNode } from '../operation-node/drop-type-node.js';
+import { ExplainNode } from '../operation-node/explain-node.js';
 export declare class DefaultQueryCompiler extends OperationNodeVisitor implements QueryCompiler {
     #private;
     protected get numParameters(): number;
@@ -149,11 +150,16 @@ export declare class DefaultQueryCompiler extends OperationNodeVisitor implement
     protected visitSelectModifier(node: SelectModifierNode): void;
     protected visitCreateType(node: CreateTypeNode): void;
     protected visitDropType(node: DropTypeNode): void;
+    protected visitExplain(node: ExplainNode): void;
     protected append(str: string): void;
     protected appendValue(parameter: unknown): void;
     protected getLeftIdentifierWrapper(): string;
     protected getRightIdentifierWrapper(): string;
     protected getCurrentParameterPlaceholder(): string;
+    protected getLeftExplainOptionsWrapper(): string;
+    protected getExplainOptionAssignment(): string;
+    protected getExplainOptionsDelimiter(): string;
+    protected getRightExplainOptionsWrapper(): string;
     protected sanitizeIdentifier(identifier: string): string;
     protected addParameter(parameter: unknown): void;
     protected appendImmediateValue(value: unknown): void;

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

@@ -30,6 +30,10 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             !InsertQueryNode.is(this.parentNode) &&
             !CreateViewNode.is(this.parentNode) &&
             !UnionNode.is(this.parentNode);
+        if (this.parentNode === undefined && node.explain) {
+            this.visitNode(node.explain);
+            this.append(' ');
+        }
         if (wrapInParens) {
             this.append('(');
         }
@@ -125,6 +129,10 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
     }
     visitInsertQuery(node) {
         const isSubQuery = this.nodeStack.find(QueryNode.is) !== node;
+        if (!isSubQuery && node.explain) {
+            this.visitNode(node.explain);
+            this.append(' ');
+        }
         if (isSubQuery) {
             this.append('(');
         }
@@ -169,6 +177,10 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
     }
     visitDeleteQuery(node) {
         const isSubQuery = this.nodeStack.find(QueryNode.is) !== node;
+        if (!isSubQuery && node.explain) {
+            this.visitNode(node.explain);
+            this.append(' ');
+        }
         if (isSubQuery) {
             this.append('(');
         }
@@ -225,6 +237,9 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
         this.append(this.getRightIdentifierWrapper());
     }
     compileUnwrappedIdentifier(node) {
+        if (!isString(node.identifier)) {
+            throw new Error('a non-string identifier was passed to compileUnwrappedIdentifier.');
+        }
         this.append(this.sanitizeIdentifier(node.identifier));
     }
     visitFilter(node) {
@@ -309,6 +324,10 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
     }
     visitCreateTable(node) {
         this.append('create ');
+        if (node.frontModifiers) {
+            this.compileList(node.frontModifiers, ' ');
+            this.append(' ');
+        }
         if (node.temporary) {
             this.append('temporary ');
         }
@@ -324,6 +343,10 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.append(' on commit ');
             this.append(node.onCommit);
         }
+        if (node.endModifiers) {
+            this.append(' ');
+            this.compileList(node.endModifiers, ' ');
+        }
     }
     visitColumnDefinition(node) {
         this.visitNode(node.column);
@@ -410,6 +433,10 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
     }
     visitUpdateQuery(node) {
         const isSubQuery = this.nodeStack.find(QueryNode.is) !== node;
+        if (!isSubQuery && node.explain) {
+            this.visitNode(node.explain);
+            this.append(' ');
+        }
         if (isSubQuery) {
             this.append('(');
         }
@@ -804,6 +831,25 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
         }
         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;
     }
@@ -820,10 +866,19 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
     getCurrentParameterPlaceholder() {
         return '$' + this.numParameters;
     }
+    getLeftExplainOptionsWrapper() {
+        return '(';
+    }
+    getExplainOptionAssignment() {
+        return ' ';
+    }
+    getExplainOptionsDelimiter() {
+        return ', ';
+    }
+    getRightExplainOptionsWrapper() {
+        return ')';
+    }
     sanitizeIdentifier(identifier) {
-        if (!isString(identifier)) {
-            throw new Error('a non-string identifier was passed to sanitizeIdentifier.');
-        }
         const leftWrap = this.getLeftIdentifierWrapper();
         const rightWrap = this.getRightIdentifierWrapper();
         let sanitized = '';