kysely 0.19.8 → 0.19.11

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

@@ -0,0 +1,22 @@
+/// <reference types="./select-modifier-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+/**
+ * @internal
+ */
+export const SelectModifierNode = freeze({
+    is(node) {
+        return node.kind === 'SelectModifierNode';
+    },
+    create(modifier) {
+        return freeze({
+            kind: 'SelectModifierNode',
+            modifier,
+        });
+    },
+    createWithRaw(modifier) {
+        return freeze({
+            kind: 'SelectModifierNode',
+            rawModifier: modifier,
+        });
+    },
+});

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

@@ -13,18 +13,18 @@ import { SelectionNode } from './selection-node.js';
 import { WhereNode } from './where-node.js';
 import { WithNode } from './with-node.js';
 import { UnionNode } from './union-node.js';
-export declare type SelectModifier = 'ForUpdate' | 'ForNoKeyUpdate' | 'ForShare' | 'ForKeyShare' | 'NoWait' | 'SkipLocked';
+import { SelectModifierNode } from './select-modifier-node.js';
 export interface SelectQueryNode extends OperationNode {
     readonly kind: 'SelectQueryNode';
     readonly from: FromNode;
     readonly selections?: ReadonlyArray<SelectionNode>;
     readonly distinctOnSelections?: ReadonlyArray<SelectionNode>;
-    readonly distinct?: boolean;
     readonly joins?: ReadonlyArray<JoinNode>;
     readonly groupBy?: GroupByNode;
     readonly orderBy?: OrderByNode;
     readonly where?: WhereNode;
-    readonly modifiers?: ReadonlyArray<SelectModifier>;
+    readonly frontModifiers?: ReadonlyArray<SelectModifierNode>;
+    readonly endModifiers?: ReadonlyArray<SelectModifierNode>;
     readonly limit?: LimitNode;
     readonly offset?: OffsetNode;
     readonly with?: WithNode;
@@ -39,13 +39,13 @@ export declare const SelectQueryNode: Readonly<{
     create(fromItems: ReadonlyArray<TableExpressionNode>, withNode?: WithNode): SelectQueryNode;
     cloneWithSelections(select: SelectQueryNode, selections: ReadonlyArray<SelectionNode>): SelectQueryNode;
     cloneWithDistinctOnSelections(select: SelectQueryNode, selections: ReadonlyArray<SelectionNode>): SelectQueryNode;
-    cloneWithModifier(select: SelectQueryNode, modifier: SelectModifier): SelectQueryNode;
+    cloneWithFrontModifier(select: SelectQueryNode, modifier: SelectModifierNode): SelectQueryNode;
+    cloneWithEndModifier(select: SelectQueryNode, modifier: SelectModifierNode): SelectQueryNode;
     cloneWithOrderByItem(selectNode: SelectQueryNode, item: OrderByItemNode): SelectQueryNode;
     cloneWithGroupByItems(selectNode: SelectQueryNode, items: ReadonlyArray<GroupByItemNode>): SelectQueryNode;
     cloneWithLimit(selectNode: SelectQueryNode, limit: LimitNode): SelectQueryNode;
     cloneWithOffset(selectNode: SelectQueryNode, offset: OffsetNode): SelectQueryNode;
     cloneWithHaving(selectNode: SelectQueryNode, filter: FilterExpressionNode): SelectQueryNode;
     cloneWithOrHaving(selectNode: SelectQueryNode, filter: FilterExpressionNode): SelectQueryNode;
-    cloneWithDistinct(selectNode: SelectQueryNode): SelectQueryNode;
     cloneWithUnion(selectNode: SelectQueryNode, union: UnionNode): SelectQueryNode;
 }>;

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

@@ -34,11 +34,19 @@ export const SelectQueryNode = freeze({
                 : freeze(selections),
         });
     },
-    cloneWithModifier(select, modifier) {
+    cloneWithFrontModifier(select, modifier) {
         return freeze({
             ...select,
-            modifiers: select.modifiers
-                ? freeze([...select.modifiers, modifier])
+            frontModifiers: select.frontModifiers
+                ? freeze([...select.frontModifiers, modifier])
+                : freeze([modifier]),
+        });
+    },
+    cloneWithEndModifier(select, modifier) {
+        return freeze({
+            ...select,
+            endModifiers: select.endModifiers
+                ? freeze([...select.endModifiers, modifier])
                 : freeze([modifier]),
         });
     },
@@ -86,12 +94,6 @@ export const SelectQueryNode = freeze({
                 : HavingNode.create(filter),
         });
     },
-    cloneWithDistinct(selectNode) {
-        return freeze({
-            ...selectNode,
-            distinct: true,
-        });
-    },
     cloneWithUnion(selectNode, union) {
         return freeze({
             ...selectNode,

package/dist/esm/plugin/with-schema/with-schema-transformer.d.ts

@@ -1,10 +1,12 @@
 import { AlterTableNode } from '../../operation-node/alter-table-node.js';
 import { CreateIndexNode } from '../../operation-node/create-index-node.js';
 import { CreateTableNode } from '../../operation-node/create-table-node.js';
+import { CreateTypeNode } from '../../operation-node/create-type-node.js';
 import { CreateViewNode } from '../../operation-node/create-view-node.js';
 import { DeleteQueryNode } from '../../operation-node/delete-query-node.js';
 import { DropIndexNode } from '../../operation-node/drop-index-node.js';
 import { DropTableNode } from '../../operation-node/drop-table-node.js';
+import { DropTypeNode } from '../../operation-node/drop-type-node.js';
 import { DropViewNode } from '../../operation-node/drop-view-node.js';
 import { InsertQueryNode } from '../../operation-node/insert-query-node.js';
 import { OperationNodeTransformer } from '../../operation-node/operation-node-transformer.js';
@@ -24,6 +26,8 @@ export declare class WithSchemaTransformer extends OperationNodeTransformer {
     protected transformDropIndex(node: DropIndexNode): DropIndexNode;
     protected transformCreateView(node: CreateViewNode): CreateViewNode;
     protected transformDropView(node: DropViewNode): DropViewNode;
+    protected transformCreateType(node: CreateTypeNode): CreateTypeNode;
+    protected transformDropType(node: DropTypeNode): DropTypeNode;
     protected transformAlterTable(node: AlterTableNode): AlterTableNode;
     protected transformTable(node: TableNode): TableNode;
 }

package/dist/esm/plugin/with-schema/with-schema-transformer.js

@@ -39,6 +39,12 @@ export class WithSchemaTransformer extends OperationNodeTransformer {
     transformDropView(node) {
         return this.#transformRoot(node, (node) => super.transformDropView(node));
     }
+    transformCreateType(node) {
+        return this.#transformRoot(node, (node) => super.transformCreateType(node));
+    }
+    transformDropType(node) {
+        return this.#transformRoot(node, (node) => super.transformDropType(node));
+    }
     transformAlterTable(node) {
         return this.#transformRoot(node, (node) => super.transformAlterTable(node));
     }

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

@@ -43,7 +43,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',

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

@@ -653,6 +653,50 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      */
     distinctOn<SE extends SelectExpression<DB, TB>>(selections: ReadonlyArray<SE>): SelectQueryBuilder<DB, TB, O>;
     distinctOn<SE extends SelectExpression<DB, TB>>(selection: SE): SelectQueryBuilder<DB, TB, O>;
+    /**
+     * This can be used to add any additional SQL to the front of the query __after__ the `select` keyword.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .modifyFront(sql`sql_no_cache`)
+     *   .select('first_name')
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * select sql_no_cache `first_name`
+     * from `person`
+     * ```
+     */
+    modifyFront(modifier: AnyRawBuilder): SelectQueryBuilder<DB, TB, O>;
+    /**
+     * This can be used to add any additional SQL to the end of the query.
+     *
+     * Also see {@link forUpdate}, {@link forShare}, {@link forKeyShare}, {@link forNoKeyUpdate}
+     * {@link skipLocked} and  {@link noWait}.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .select('first_name')
+     *   .modifyEnd(sql`for update`)
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select "first_name"
+     * from "person"
+     * for update
+     * ```
+     */
+    modifyEnd(modifier: AnyRawBuilder): SelectQueryBuilder<DB, TB, O>;
     /**
      * Makes the selection distinct.
      *
@@ -673,27 +717,27 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      */
     distinct(): SelectQueryBuilder<DB, TB, O>;
     /**
-     * Adds the `for update` option to a select query on supported databases.
+     * Adds the `for update` modifier to a select query on supported databases.
      */
     forUpdate(): SelectQueryBuilder<DB, TB, O>;
     /**
-     * Adds the `for share` option to a select query on supported databases.
+     * Adds the `for share` modifier to a select query on supported databases.
      */
     forShare(): SelectQueryBuilder<DB, TB, O>;
     /**
-     * Adds the `for key share` option to a select query on supported databases.
+     * Adds the `for key share` modifier to a select query on supported databases.
      */
     forKeyShare(): SelectQueryBuilder<DB, TB, O>;
     /**
-     * Adds the `for no key update` option to a select query on supported databases.
+     * Adds the `for no key update` modifier to a select query on supported databases.
      */
     forNoKeyUpdate(): SelectQueryBuilder<DB, TB, O>;
     /**
-     * Adds the `skip locked` option to a select query on supported databases.
+     * Adds the `skip locked` modifier to a select query on supported databases.
      */
     skipLocked(): SelectQueryBuilder<DB, TB, O>;
     /**
-     * Adds the `nowait` option to a select query on supported databases.
+     * Adds the `nowait` modifier to a select query on supported databases.
      */
     noWait(): SelectQueryBuilder<DB, TB, O>;
     /**
@@ -1299,6 +1343,33 @@ 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>;
 }
 export interface SelectQueryBuilderProps {
     readonly queryId: QueryId;

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

@@ -1,5 +1,6 @@
 /// <reference types="./select-query-builder.d.ts" />
 import { AliasNode } from '../operation-node/alias-node.js';
+import { SelectModifierNode } from '../operation-node/select-modifier-node.js';
 import { parseJoin, } from '../parser/join-parser.js';
 import { parseSelectExpressionOrList, parseSelectAll, } from '../parser/select-parser.js';
 import { parseExistFilter, parseReferenceFilter, parseWhereFilter, parseHavingFilter, parseNotExistFilter, } from '../parser/filter-parser.js';
@@ -127,6 +128,60 @@ export class SelectQueryBuilder {
             queryNode: SelectQueryNode.cloneWithDistinctOnSelections(this.#props.queryNode, parseSelectExpressionOrList(selection)),
         });
     }
+    /**
+     * This can be used to add any additional SQL to the front of the query __after__ the `select` keyword.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .modifyFront(sql`sql_no_cache`)
+     *   .select('first_name')
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * select sql_no_cache `first_name`
+     * from `person`
+     * ```
+     */
+    modifyFront(modifier) {
+        return new SelectQueryBuilder({
+            ...this.#props,
+            queryNode: SelectQueryNode.cloneWithFrontModifier(this.#props.queryNode, SelectModifierNode.createWithRaw(modifier.toOperationNode())),
+        });
+    }
+    /**
+     * This can be used to add any additional SQL to the end of the query.
+     *
+     * Also see {@link forUpdate}, {@link forShare}, {@link forKeyShare}, {@link forNoKeyUpdate}
+     * {@link skipLocked} and  {@link noWait}.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .select('first_name')
+     *   .modifyEnd(sql`for update`)
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select "first_name"
+     * from "person"
+     * for update
+     * ```
+     */
+    modifyEnd(modifier) {
+        return new SelectQueryBuilder({
+            ...this.#props,
+            queryNode: SelectQueryNode.cloneWithEndModifier(this.#props.queryNode, SelectModifierNode.createWithRaw(modifier.toOperationNode())),
+        });
+    }
     /**
      * Makes the selection distinct.
      *
@@ -148,61 +203,61 @@ export class SelectQueryBuilder {
     distinct() {
         return new SelectQueryBuilder({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithDistinct(this.#props.queryNode),
+            queryNode: SelectQueryNode.cloneWithFrontModifier(this.#props.queryNode, SelectModifierNode.create('Distinct')),
         });
     }
     /**
-     * Adds the `for update` option to a select query on supported databases.
+     * Adds the `for update` modifier to a select query on supported databases.
      */
     forUpdate() {
         return new SelectQueryBuilder({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithModifier(this.#props.queryNode, 'ForUpdate'),
+            queryNode: SelectQueryNode.cloneWithEndModifier(this.#props.queryNode, SelectModifierNode.create('ForUpdate')),
         });
     }
     /**
-     * Adds the `for share` option to a select query on supported databases.
+     * Adds the `for share` modifier to a select query on supported databases.
      */
     forShare() {
         return new SelectQueryBuilder({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithModifier(this.#props.queryNode, 'ForShare'),
+            queryNode: SelectQueryNode.cloneWithEndModifier(this.#props.queryNode, SelectModifierNode.create('ForShare')),
         });
     }
     /**
-     * Adds the `for key share` option to a select query on supported databases.
+     * Adds the `for key share` modifier to a select query on supported databases.
      */
     forKeyShare() {
         return new SelectQueryBuilder({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithModifier(this.#props.queryNode, 'ForKeyShare'),
+            queryNode: SelectQueryNode.cloneWithEndModifier(this.#props.queryNode, SelectModifierNode.create('ForKeyShare')),
         });
     }
     /**
-     * Adds the `for no key update` option to a select query on supported databases.
+     * Adds the `for no key update` modifier to a select query on supported databases.
      */
     forNoKeyUpdate() {
         return new SelectQueryBuilder({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithModifier(this.#props.queryNode, 'ForNoKeyUpdate'),
+            queryNode: SelectQueryNode.cloneWithEndModifier(this.#props.queryNode, SelectModifierNode.create('ForNoKeyUpdate')),
         });
     }
     /**
-     * Adds the `skip locked` option to a select query on supported databases.
+     * Adds the `skip locked` modifier to a select query on supported databases.
      */
     skipLocked() {
         return new SelectQueryBuilder({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithModifier(this.#props.queryNode, 'SkipLocked'),
+            queryNode: SelectQueryNode.cloneWithEndModifier(this.#props.queryNode, SelectModifierNode.create('SkipLocked')),
         });
     }
     /**
-     * Adds the `nowait` option to a select query on supported databases.
+     * Adds the `nowait` modifier to a select query on supported databases.
      */
     noWait() {
         return new SelectQueryBuilder({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithModifier(this.#props.queryNode, 'NoWait'),
+            queryNode: SelectQueryNode.cloneWithEndModifier(this.#props.queryNode, SelectModifierNode.create('NoWait')),
         });
     }
     selectAll(table) {
@@ -573,7 +628,6 @@ export class SelectQueryBuilder {
      */
     async execute() {
         const compildQuery = this.compile();
-        const query = compildQuery.query;
         const result = await this.#props.executor.executeQuery(compildQuery, this.#props.queryId);
         return result.rows;
     }
@@ -600,6 +654,39 @@ export class SelectQueryBuilder {
         }
         return result;
     }
+    /**
+     * 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
+     *   }
+     * }
+     * ```
+     */
+    async *stream(chunkSize = 100) {
+        const compildQuery = this.compile();
+        const stream = this.#props.executor.stream(compildQuery, chunkSize, this.#props.queryId);
+        for await (const item of stream) {
+            yield* item.rows;
+        }
+    }
 }
 preventAwait(SelectQueryBuilder, "don't await SelectQueryBuilder instances directly. To execute the query you need to call `execute` or `executeTakeFirst`.");
 /**

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

@@ -68,6 +68,9 @@ import { DefaultValueNode } from '../operation-node/default-value-node.js';
 import { OnNode } from '../operation-node/on-node.js';
 import { ValuesNode } from '../operation-node/values-node.js';
 import { CommonTableExpressionNameNode } from '../operation-node/common-table-expression-name-node.js';
+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';
 export declare class DefaultQueryCompiler extends OperationNodeVisitor implements QueryCompiler {
     #private;
     protected get numParameters(): number;
@@ -143,6 +146,9 @@ export declare class DefaultQueryCompiler extends OperationNodeVisitor implement
     protected visitDropView(node: DropViewNode): void;
     protected visitGenerated(node: GeneratedNode): void;
     protected visitDefaultValue(node: DefaultValueNode): void;
+    protected visitSelectModifier(node: SelectModifierNode): void;
+    protected visitCreateType(node: CreateTypeNode): void;
+    protected visitDropType(node: DropTypeNode): void;
     protected append(str: string): void;
     protected appendValue(parameter: unknown): void;
     protected getLeftIdentifierWrapper(): string;

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

@@ -42,8 +42,8 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.compileDistinctOn(node.distinctOnSelections);
             this.append(' ');
         }
-        if (node.distinct) {
-            this.append('distinct');
+        if (node.frontModifiers && node.frontModifiers.length > 0) {
+            this.compileList(node.frontModifiers, ' ');
             this.append(' ');
         }
         if (node.selections) {
@@ -83,11 +83,9 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.append(' ');
             this.visitNode(node.offset);
         }
-        if (node.modifiers) {
-            node.modifiers.forEach((modifier) => {
-                this.append(' ');
-                this.append(SELECT_MODIFIER_SQL[modifier]);
-            });
+        if (node.endModifiers && node.endModifiers.length > 0) {
+            this.append(' ');
+            this.compileList(node.endModifiers, ' ');
         }
         if (wrapInParens) {
             this.append(')');
@@ -134,7 +132,7 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.visitNode(node.with);
             this.append(' ');
         }
-        this.append('insert');
+        this.append(node.replace ? 'replace' : 'insert');
         if (node.ignore) {
             this.append(' ignore');
         }
@@ -783,6 +781,29 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
         this.append('default ');
         this.visitNode(node.defaultValue);
     }
+    visitSelectModifier(node) {
+        if (node.rawModifier) {
+            this.visitNode(node.rawModifier);
+        }
+        else {
+            this.append(SELECT_MODIFIER_SQL[node.modifier]);
+        }
+    }
+    visitCreateType(node) {
+        this.append('create type ');
+        this.visitNode(node.name);
+        if (node.enum) {
+            this.append(' as enum ');
+            this.visitNode(node.enum);
+        }
+    }
+    visitDropType(node) {
+        this.append('drop type ');
+        if (node.ifExists) {
+            this.append('if exists ');
+        }
+        this.visitNode(node.name);
+    }
     append(str) {
         this.#sql += str;
     }
@@ -830,6 +851,7 @@ const SELECT_MODIFIER_SQL = freeze({
     ForShare: 'for share',
     NoWait: 'nowait',
     SkipLocked: 'skip locked',
+    Distinct: 'distinct',
 });
 const JOIN_TYPE_SQL = freeze({
     InnerJoin: 'inner join',

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

@@ -2,15 +2,17 @@ import { AlterTableNode } from '../operation-node/alter-table-node.js';
 import { CreateIndexNode } from '../operation-node/create-index-node.js';
 import { CreateSchemaNode } from '../operation-node/create-schema-node.js';
 import { CreateTableNode } from '../operation-node/create-table-node.js';
+import { CreateTypeNode } from '../operation-node/create-type-node.js';
 import { CreateViewNode } from '../operation-node/create-view-node.js';
 import { DropIndexNode } from '../operation-node/drop-index-node.js';
 import { DropSchemaNode } from '../operation-node/drop-schema-node.js';
 import { DropTableNode } from '../operation-node/drop-table-node.js';
+import { DropTypeNode } from '../operation-node/drop-type-node.js';
 import { DropViewNode } from '../operation-node/drop-view-node.js';
 import { QueryNode } from '../operation-node/query-node.js';
 import { RawNode } from '../operation-node/raw-node.js';
 import { CompiledQuery } from './compiled-query.js';
-export declare type RootOperationNode = QueryNode | CreateTableNode | CreateIndexNode | CreateSchemaNode | CreateViewNode | DropTableNode | DropIndexNode | DropSchemaNode | DropViewNode | AlterTableNode | RawNode;
+export declare type RootOperationNode = QueryNode | CreateTableNode | CreateIndexNode | CreateSchemaNode | CreateViewNode | DropTableNode | DropIndexNode | DropSchemaNode | DropViewNode | AlterTableNode | RawNode | CreateTypeNode | DropTypeNode;
 /**
  * a `QueryCompiler` compiles a query expressed as a tree of `OperationNodes` into SQL.
  */

package/dist/esm/query-creator.d.ts

@@ -161,6 +161,33 @@ export declare class QueryCreator<DB> {
      * ```
      */
     insertInto<T extends keyof DB & string>(table: T): InsertQueryBuilder<DB, T, InsertResult>;
+    /**
+     * Creates a replace query.
+     *
+     * A MySQL-only statement similar to {@link InsertQueryBuilder.onDuplicateKeyUpdate}
+     * that deletes and inserts values on collision instead of updating existing rows.
+     *
+     * The return value of this query is an instance of {@link InsertResult}. {@link InsertResult}
+     * has the {@link InsertResult.insertId | insertId} field that holds the auto incremented id of
+     * the inserted row if the db returned one.
+     *
+     * See the {@link InsertQueryBuilder.values | values} method for more info and examples.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const result = await db
+     *   .replaceInto('person')
+     *   .values({
+     *     first_name: 'Jennifer',
+     *     last_name: 'Aniston'
+     *   })
+     *   .executeTakeFirst()
+     *
+     * console.log(result.insertId)
+     * ```
+     */
+    replaceInto<T extends keyof DB & string>(table: T): InsertQueryBuilder<DB, T, InsertResult>;
     /**
      * Creates a delete query.
      *

package/dist/esm/query-creator.js

@@ -70,6 +70,39 @@ export class QueryCreator {
             queryNode: InsertQueryNode.create(parseTable(table), this.#props.withNode),
         });
     }
+    /**
+     * Creates a replace query.
+     *
+     * A MySQL-only statement similar to {@link InsertQueryBuilder.onDuplicateKeyUpdate}
+     * that deletes and inserts values on collision instead of updating existing rows.
+     *
+     * The return value of this query is an instance of {@link InsertResult}. {@link InsertResult}
+     * has the {@link InsertResult.insertId | insertId} field that holds the auto incremented id of
+     * the inserted row if the db returned one.
+     *
+     * See the {@link InsertQueryBuilder.values | values} method for more info and examples.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const result = await db
+     *   .replaceInto('person')
+     *   .values({
+     *     first_name: 'Jennifer',
+     *     last_name: 'Aniston'
+     *   })
+     *   .executeTakeFirst()
+     *
+     * console.log(result.insertId)
+     * ```
+     */
+    replaceInto(table) {
+        return new InsertQueryBuilder({
+            queryId: createQueryId(),
+            executor: this.#props.executor,
+            queryNode: InsertQueryNode.create(parseTable(table), this.#props.withNode, true),
+        });
+    }
     /**
      * Creates a delete query.
      *

package/dist/esm/query-executor/query-executor-base.d.ts

@@ -36,6 +36,12 @@ export declare abstract class QueryExecutorBase implements QueryExecutor {
      * `transformResult` method.
      */
     executeQuery<R>(compiledQuery: CompiledQuery, queryId: QueryId): Promise<QueryResult<R>>;
+    /**
+     * Executes a compiled query and runs the result through all plugins'
+     * `transformResult` method. Results are streamead instead of loaded
+     * at once.
+     */
+    stream<R>(compiledQuery: CompiledQuery, chunkSize: number, queryId: QueryId): AsyncIterableIterator<QueryResult<R>>;
     /**
      * Returns a copy of this executor with a new connection provider.
      */