kysely 0.19.10 → 0.20.0

package/dist/cjs/operation-node/explain-node.d.ts

@@ -0,0 +1,16 @@
+import { ExplainFormat } from '../util/explainable.js';
+import { AnyRawBuilder } from '../util/type-utils.js';
+import { OperationNode } from './operation-node.js';
+import { RawNode } from './raw-node.js';
+export interface ExplainNode extends OperationNode {
+    readonly kind: 'ExplainNode';
+    readonly format?: ExplainFormat;
+    readonly options?: RawNode;
+}
+/**
+ * @internal
+ */
+export declare const ExplainNode: Readonly<{
+    is(node: OperationNode): node is ExplainNode;
+    create(format?: ExplainFormat, options?: AnyRawBuilder): ExplainNode;
+}>;

package/dist/cjs/operation-node/explain-node.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExplainNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+/**
+ * @internal
+ */
+exports.ExplainNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'ExplainNode';
+    },
+    create(format, options) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'ExplainNode',
+            format,
+            options: options?.toOperationNode(),
+        });
+    },
+});

package/dist/cjs/operation-node/foreign-key-constraint-node.d.ts

@@ -20,8 +20,8 @@ export declare const ForeignKeyConstraintNode: Readonly<{
     create(sourceColumns: ReadonlyArray<ColumnNode>, targetTable: TableNode, targetColumns: ReadonlyArray<ColumnNode>, constraintName?: string): ForeignKeyConstraintNode;
     cloneWith(node: ForeignKeyConstraintNode, props: ForeignKeyConstraintNodeProps): Readonly<{
         name?: IdentifierNode | undefined;
-        onDelete?: OnModifyForeignAction | undefined;
-        onUpdate?: OnModifyForeignAction | undefined;
+        onDelete?: "no action" | "restrict" | "cascade" | "set null" | "set default" | undefined;
+        onUpdate?: "no action" | "restrict" | "cascade" | "set null" | "set default" | undefined;
         kind: 'ForeignKeyConstraintNode';
         columns: ReadonlyArray<ColumnNode>;
         references: ReferencesNode;

package/dist/cjs/operation-node/insert-query-node.d.ts

@@ -1,4 +1,5 @@
 import { ColumnNode } from './column-node.js';
+import { ExplainNode } from './explain-node.js';
 import { OnConflictNode } from './on-conflict-node.js';
 import { OnDuplicateKeyNode } from './on-duplicate-key-node.js';
 import { OperationNode } from './operation-node.js';
@@ -19,12 +20,14 @@ export interface InsertQueryNode extends OperationNode {
     readonly onDuplicateKey?: OnDuplicateKeyNode;
     readonly with?: WithNode;
     readonly ignore?: boolean;
+    readonly replace?: boolean;
+    readonly explain?: ExplainNode;
 }
 /**
  * @internal
  */
 export declare const InsertQueryNode: Readonly<{
     is(node: OperationNode): node is InsertQueryNode;
-    create(into: TableNode, withNode?: WithNode): InsertQueryNode;
+    create(into: TableNode, withNode?: WithNode, replace?: boolean): InsertQueryNode;
     cloneWith(insertQuery: InsertQueryNode, props: InsertQueryNodeProps): InsertQueryNode;
 }>;

package/dist/cjs/operation-node/insert-query-node.js

@@ -9,11 +9,12 @@ exports.InsertQueryNode = (0, object_utils_js_1.freeze)({
     is(node) {
         return node.kind === 'InsertQueryNode';
     },
-    create(into, withNode) {
+    create(into, withNode, replace) {
         return (0, object_utils_js_1.freeze)({
             kind: 'InsertQueryNode',
             into,
             ...(withNode && { with: withNode }),
+            replace,
         });
     },
     cloneWith(insertQuery, props) {

package/dist/cjs/operation-node/operation-node-transformer.d.ts

@@ -68,6 +68,7 @@ import { ValuesNode } from './values-node.js';
 import { SelectModifierNode } from './select-modifier-node.js';
 import { CreateTypeNode } from './create-type-node.js';
 import { DropTypeNode } from './drop-type-node.js';
+import { ExplainNode } from './explain-node.js';
 /**
  * Transforms an operation node tree into another one.
  *
@@ -172,4 +173,5 @@ export declare class OperationNodeTransformer {
     protected transformValue(node: ValueNode): ValueNode;
     protected transformPrimitiveValueList(node: PrimitiveValueListNode): PrimitiveValueListNode;
     protected transformOperator(node: OperatorNode): OperatorNode;
+    protected transformExplain(node: ExplainNode): ExplainNode;
 }

package/dist/cjs/operation-node/operation-node-transformer.js

@@ -104,6 +104,7 @@ class OperationNodeTransformer {
         SelectModifierNode: this.transformSelectModifier.bind(this),
         CreateTypeNode: this.transformCreateType.bind(this),
         DropTypeNode: this.transformDropType.bind(this),
+        ExplainNode: this.transformExplain.bind(this),
     });
     transformNode = (node) => {
         if (!node) {
@@ -137,6 +138,7 @@ class OperationNodeTransformer {
             with: this.transformNode(node.with),
             having: this.transformNode(node.having),
             union: this.transformNodeList(node.union),
+            explain: this.transformNode(node.explain),
         });
     }
     transformSelection(node) {
@@ -244,6 +246,8 @@ class OperationNodeTransformer {
             onDuplicateKey: this.transformNode(node.onDuplicateKey),
             with: this.transformNode(node.with),
             ignore: node.ignore,
+            replace: node.replace,
+            explain: this.transformNode(node.explain),
         });
     }
     transformValues(node) {
@@ -262,6 +266,7 @@ class OperationNodeTransformer {
             with: this.transformNode(node.with),
             orderBy: this.transformNode(node.orderBy),
             limit: this.transformNode(node.limit),
+            explain: this.transformNode(node.explain),
         });
     }
     transformReturning(node) {
@@ -279,6 +284,8 @@ class OperationNodeTransformer {
             temporary: node.temporary,
             ifNotExists: node.ifNotExists,
             onCommit: node.onCommit,
+            frontModifiers: this.transformNodeList(node.frontModifiers),
+            endModifiers: this.transformNodeList(node.endModifiers),
         });
     }
     transformColumnDefinition(node) {
@@ -345,6 +352,7 @@ class OperationNodeTransformer {
             updates: this.transformNodeList(node.updates),
             returning: this.transformNode(node.returning),
             with: this.transformNode(node.with),
+            explain: this.transformNode(node.explain),
         });
     }
     transformColumnUpdate(node) {
@@ -643,5 +651,12 @@ class OperationNodeTransformer {
         // An Object.freezed leaf node. No need to clone.
         return node;
     }
+    transformExplain(node) {
+        return (0, require_all_props_js_1.requireAllProps)({
+            kind: 'ExplainNode',
+            format: node.format,
+            options: this.transformNode(node.options),
+        });
+    }
 }
 exports.OperationNodeTransformer = OperationNodeTransformer;

package/dist/cjs/operation-node/operation-node-visitor.d.ts

@@ -68,6 +68,7 @@ import { ValuesNode } from './values-node.js';
 import { SelectModifierNode } from './select-modifier-node.js';
 import { CreateTypeNode } from './create-type-node.js';
 import { DropTypeNode } from './drop-type-node.js';
+import { ExplainNode } from './explain-node.js';
 export declare abstract class OperationNodeVisitor {
     #private;
     protected readonly nodeStack: OperationNode[];
@@ -142,4 +143,5 @@ export declare abstract class OperationNodeVisitor {
     protected abstract visitSelectModifier(node: SelectModifierNode): void;
     protected abstract visitCreateType(node: CreateTypeNode): void;
     protected abstract visitDropType(node: DropTypeNode): void;
+    protected abstract visitExplain(node: ExplainNode): void;
 }

package/dist/cjs/operation-node/operation-node-visitor.js

@@ -77,6 +77,7 @@ class OperationNodeVisitor {
         SelectModifierNode: this.visitSelectModifier.bind(this),
         CreateTypeNode: this.visitCreateType.bind(this),
         DropTypeNode: this.visitDropType.bind(this),
+        ExplainNode: this.visitExplain.bind(this),
     });
     visitNode = (node) => {
         this.nodeStack.push(node);

package/dist/cjs/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/cjs/operation-node/references-node.d.ts

@@ -1,7 +1,9 @@
 import { OperationNode } from './operation-node.js';
 import { ColumnNode } from './column-node.js';
 import { TableNode } from './table-node.js';
-export declare type OnModifyForeignAction = 'no action' | 'restrict' | 'cascade' | 'set null' | 'set default';
+import { ArrayItemType } from '../util/type-utils.js';
+export declare const ON_MODIFY_FOREIGN_ACTIONS: readonly ["no action", "restrict", "cascade", "set null", "set default"];
+export declare type OnModifyForeignAction = ArrayItemType<typeof ON_MODIFY_FOREIGN_ACTIONS>;
 export interface ReferencesNode extends OperationNode {
     readonly kind: 'ReferencesNode';
     readonly table: TableNode;

package/dist/cjs/operation-node/references-node.js

@@ -1,7 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ReferencesNode = void 0;
+exports.ReferencesNode = exports.ON_MODIFY_FOREIGN_ACTIONS = void 0;
 const object_utils_js_1 = require("../util/object-utils.js");
+exports.ON_MODIFY_FOREIGN_ACTIONS = [
+    'no action',
+    'restrict',
+    'cascade',
+    'set null',
+    'set default',
+];
 /**
  * @internal
  */

package/dist/cjs/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/cjs/operation-node/select-query-node.js

@@ -104,4 +104,10 @@ exports.SelectQueryNode = (0, object_utils_js_1.freeze)({
                 : (0, object_utils_js_1.freeze)([union]),
         });
     },
+    cloneWithExplain(selectNode, explain) {
+        return (0, object_utils_js_1.freeze)({
+            ...selectNode,
+            explain,
+        });
+    },
 });

package/dist/cjs/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/cjs/operation-node/update-query-node.js

@@ -33,4 +33,10 @@ exports.UpdateQueryNode = (0, object_utils_js_1.freeze)({
                 : updates,
         });
     },
+    cloneWithExplain(updateQuery, explain) {
+        return (0, object_utils_js_1.freeze)({
+            ...updateQuery,
+            explain,
+        });
+    },
 });

package/dist/cjs/parser/on-commit-action-parse.d.ts

@@ -0,0 +1,2 @@
+import { OnCommitAction } from '../operation-node/create-table-node.js';
+export declare function parseOnCommitAction(action: OnCommitAction): OnCommitAction;

package/dist/cjs/parser/on-commit-action-parse.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseOnCommitAction = void 0;
+const create_table_node_js_1 = require("../operation-node/create-table-node.js");
+function parseOnCommitAction(action) {
+    if (create_table_node_js_1.ON_COMMIT_ACTIONS.includes(action)) {
+        return action;
+    }
+    throw new Error(`invalid OnCommitAction ${action}`);
+}
+exports.parseOnCommitAction = parseOnCommitAction;

package/dist/cjs/parser/on-modify-action-parser.d.ts

@@ -0,0 +1,2 @@
+import { OnModifyForeignAction } from '../operation-node/references-node.js';
+export declare function parseOnModifyForeignAction(action: OnModifyForeignAction): OnModifyForeignAction;

package/dist/cjs/parser/on-modify-action-parser.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseOnModifyForeignAction = void 0;
+const references_node_js_1 = require("../operation-node/references-node.js");
+function parseOnModifyForeignAction(action) {
+    if (references_node_js_1.ON_MODIFY_FOREIGN_ACTIONS.includes(action)) {
+        return action;
+    }
+    throw new Error(`invalid OnModifyForeignAction ${action}`);
+}
+exports.parseOnModifyForeignAction = parseOnModifyForeignAction;

package/dist/cjs/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/cjs/query-builder/delete-query-builder.js

@@ -12,6 +12,7 @@ const delete_result_js_1 = require("./delete-result.js");
 const delete_query_node_js_1 = require("../operation-node/delete-query-node.js");
 const limit_node_js_1 = require("../operation-node/limit-node.js");
 const order_by_parser_js_1 = require("../parser/order-by-parser.js");
+const explain_node_js_1 = require("../operation-node/explain-node.js");
 class DeleteQueryBuilder {
     #props;
     constructor(props) {
@@ -295,6 +296,29 @@ 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: delete_query_node_js_1.DeleteQueryNode.cloneWithExplain(this.#props.queryNode, explain_node_js_1.ExplainNode.create(format, options)),
+        });
+        return await builder.execute();
+    }
 }
 exports.DeleteQueryBuilder = DeleteQueryBuilder;
 (0, prevent_await_js_1.preventAwait)(DeleteQueryBuilder, "don't await DeleteQueryBuilder instances directly. To execute the query you need to call `execute` or `executeTakeFirst`.");

package/dist/cjs/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/cjs/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);
     /**
@@ -43,7 +44,7 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      *
      * Insert a row into `person`:
      * ```ts
-     * const id = await db
+     * const result = await db
      *   .insertInto('person')
      *   .values({
      *     first_name: 'Jennifer',
@@ -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/cjs/query-builder/insert-query-builder.js

@@ -15,6 +15,7 @@ const complex_expression_parser_js_1 = require("../parser/complex-expression-par
 const column_node_js_1 = require("../operation-node/column-node.js");
 const on_conflict_builder_js_1 = require("./on-conflict-builder.js");
 const on_conflict_node_js_1 = require("../operation-node/on-conflict-node.js");
+const explain_node_js_1 = require("../operation-node/explain-node.js");
 class InsertQueryBuilder {
     #props;
     constructor(props) {
@@ -446,6 +447,31 @@ 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: insert_query_node_js_1.InsertQueryNode.cloneWith(this.#props.queryNode, {
+                explain: explain_node_js_1.ExplainNode.create(format, options),
+            }),
+        });
+        return await builder.execute();
+    }
 }
 exports.InsertQueryBuilder = InsertQueryBuilder;
 (0, prevent_await_js_1.preventAwait)(InsertQueryBuilder, "don't await InsertQueryBuilder instances directly. To execute the query you need to call `execute` or `executeTakeFirst`.");

package/dist/cjs/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);
     /**
@@ -1343,6 +1344,69 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      * error.
      */
     executeTakeFirstOrThrow(errorConstructor?: NoResultErrorConstructor): Promise<O>;
+    /**
+     * Executes the query and streams the rows.
+     *
+     * The optional argument `chunkSize` defines how many rows to fetch from the database
+     * at a time. It only affects some dialects like PostgreSQL that support it.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const stream = db.
+     *   .selectFrom('person')
+     *   .select(['first_name', 'last_name'])
+     *   .where('gender', '=', 'other')
+     *   .stream()
+     *
+     * for await (const person of stream) {
+     *   console.log(person.first_name)
+     *
+     *   if (person.last_name === 'Something') {
+     *     // Breaking or returning before the stream has ended will release
+     *     // the database connection and invalidate the stream.
+     *     break
+     *   }
+     * }
+     * ```
+     */
+    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;