kysely 0.7.1 → 0.7.5

package/dist/cjs/parser/parse-context.js

@@ -1,42 +1,50 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createParseContext = void 0;
-const index_js_1 = require("../index.js");
+exports.DefaultParseContext = void 0;
 const join_node_js_1 = require("../operation-node/join-node.js");
+const select_query_node_js_1 = require("../operation-node/select-query-node.js");
 const join_builder_js_1 = require("../query-builder/join-builder.js");
 const query_builder_js_1 = require("../query-builder/query-builder.js");
-const sub_query_builder_js_1 = require("../query-builder/sub-query-builder.js");
+const expression_builder_js_1 = require("../query-builder/expression-builder.js");
 const query_creator_js_1 = require("../query-creator.js");
-const object_utils_js_1 = require("../util/object-utils.js");
+const noop_query_executor_js_1 = require("../query-executor/noop-query-executor.js");
 const query_id_js_1 = require("../util/query-id.js");
-function createParseContext(adapter) {
-    return (0, object_utils_js_1.freeze)({
-        createEmptySelectQuery() {
-            return new query_builder_js_1.QueryBuilder({
-                queryId: (0, query_id_js_1.createQueryId)(),
-                executor: new index_js_1.NoopQueryExecutor(),
-                queryNode: index_js_1.SelectQueryNode.create([]),
-                adapter,
-            });
-        },
-        createSubQueryBuilder() {
-            return new sub_query_builder_js_1.SubQueryBuilder({
-                executor: new index_js_1.NoopQueryExecutor(),
-                adapter,
-            });
-        },
-        createQueryCreator() {
-            return new query_creator_js_1.QueryCreator({
-                executor: new index_js_1.NoopQueryExecutor(),
-                adapter,
-            });
-        },
-        createJoinBuilder(joinType, tableNode) {
-            return new join_builder_js_1.JoinBuilder({
-                joinNode: join_node_js_1.JoinNode.create(joinType, tableNode),
-                adapter,
-            });
-        },
-    });
+const table_parser_js_1 = require("./table-parser.js");
+class DefaultParseContext {
+    #adapter;
+    #noopExecutor;
+    constructor(adapter) {
+        this.#adapter = adapter;
+        this.#noopExecutor = new noop_query_executor_js_1.NoopQueryExecutor();
+    }
+    get adapter() {
+        return this.#adapter;
+    }
+    createSelectQueryBuilder(tables) {
+        return new query_builder_js_1.QueryBuilder({
+            queryId: (0, query_id_js_1.createQueryId)(),
+            executor: this.#noopExecutor,
+            parseContext: this,
+            queryNode: select_query_node_js_1.SelectQueryNode.create((0, table_parser_js_1.parseTableExpressionOrList)(this, tables)),
+        });
+    }
+    createJoinBuilder(joinType, table) {
+        return new join_builder_js_1.JoinBuilder({
+            joinNode: join_node_js_1.JoinNode.create(joinType, (0, table_parser_js_1.parseTableExpression)(this, table)),
+            parseContext: this,
+        });
+    }
+    createExpressionBuilder() {
+        return new expression_builder_js_1.ExpressionBuilder({
+            executor: this.#noopExecutor,
+            parseContext: this,
+        });
+    }
+    createQueryCreator() {
+        return new query_creator_js_1.QueryCreator({
+            executor: this.#noopExecutor,
+            parseContext: this,
+        });
+    }
 }
-exports.createParseContext = createParseContext;
+exports.DefaultParseContext = DefaultParseContext;

package/dist/cjs/parser/reference-parser.d.ts

@@ -14,7 +14,7 @@ export declare type ExtractTypeFromReferenceExpression<DB, TB extends keyof DB,
 declare type ExtractTypeFromStringReference<DB, TB extends keyof DB, S extends string, R = RowType<DB, TB>> = S extends `${infer SC}.${infer T}.${infer C}` ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : S extends `${infer T}.${infer C}` ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : S extends keyof R ? R[S] : PrimitiveValue;
 export declare function parseReferenceExpressionOrList(ctx: ParseContext, arg: ReferenceExpressionOrList<any, any>): ReferenceExpressionNode[];
 export declare function parseReferenceExpression(ctx: ParseContext, arg: ReferenceExpression<any, any>): ReferenceExpressionNode;
-export declare function parseStringReference(str: string): ColumnNode | ReferenceNode;
-export declare function parseAliasedStringReference(str: string): ColumnNode | ReferenceNode | AliasNode;
+export declare function parseStringReference(ref: string): ColumnNode | ReferenceNode;
+export declare function parseAliasedStringReference(ref: string): ColumnNode | ReferenceNode | AliasNode;
 export declare function parseColumnName(column: AnyColumn<any, any>): ColumnNode;
 export {};

package/dist/cjs/parser/reference-parser.js

@@ -28,7 +28,7 @@ function parseReferenceExpression(ctx, arg) {
         }
     }
     else if ((0, object_utils_js_1.isFunction)(arg)) {
-        const node = arg(ctx.createSubQueryBuilder()).toOperationNode();
+        const node = arg(ctx.createExpressionBuilder()).toOperationNode();
         if (!query_node_js_1.QueryNode.isMutating(node)) {
             return node;
         }
@@ -36,9 +36,10 @@ function parseReferenceExpression(ctx, arg) {
     throw new Error(`invalid reference expression ${JSON.stringify(arg)}`);
 }
 exports.parseReferenceExpression = parseReferenceExpression;
-function parseStringReference(str) {
-    if (str.includes('.')) {
-        const parts = str.split('.').map((it) => it.trim());
+function parseStringReference(ref) {
+    const COLUMN_SEPARATOR = '.';
+    if (ref.includes(COLUMN_SEPARATOR)) {
+        const parts = ref.split(COLUMN_SEPARATOR).map(trim);
         if (parts.length === 3) {
             return parseStringReferenceWithTableAndSchema(parts);
         }
@@ -46,22 +47,22 @@ function parseStringReference(str) {
             return parseStringReferenceWithTable(parts);
         }
         else {
-            throw new Error(`invalid column reference ${str}`);
+            throw new Error(`invalid column reference ${ref}`);
         }
     }
     else {
-        return column_node_js_1.ColumnNode.create(str);
+        return column_node_js_1.ColumnNode.create(ref);
     }
 }
 exports.parseStringReference = parseStringReference;
-function parseAliasedStringReference(str) {
-    if (str.includes(' as ')) {
-        const [tableColumn, alias] = str.split(' as ').map((it) => it.trim());
-        const tableColumnNode = parseStringReference(tableColumn);
-        return alias_node_js_1.AliasNode.create(tableColumnNode, alias);
+function parseAliasedStringReference(ref) {
+    const ALIAS_SEPARATOR = ' as ';
+    if (ref.includes(ALIAS_SEPARATOR)) {
+        const [columnRef, alias] = ref.split(ALIAS_SEPARATOR).map(trim);
+        return alias_node_js_1.AliasNode.create(parseStringReference(columnRef), alias);
     }
     else {
-        return parseStringReference(str);
+        return parseStringReference(ref);
     }
 }
 exports.parseAliasedStringReference = parseAliasedStringReference;
@@ -77,3 +78,6 @@ function parseStringReferenceWithTable(parts) {
     const [table, column] = parts;
     return reference_node_js_1.ReferenceNode.create(table_node_js_1.TableNode.create(table), column_node_js_1.ColumnNode.create(column));
 }
+function trim(str) {
+    return str.trim();
+}

package/dist/cjs/parser/select-parser.d.ts

@@ -26,6 +26,5 @@ declare type ExtractAliasFromStringSelectExpression<S extends string> = S extend
 declare type ExtractTypeFromSelectExpression<DB, TB extends keyof DB, S, A extends keyof any> = S extends string ? ExtractTypeFromStringSelectExpression<DB, TB, S, A> : S extends AliasedRawBuilder<infer O, infer RA> ? RA extends A ? O : never : S extends (qb: any) => AliasedRawBuilder<infer O, infer RA> ? RA extends A ? O : never : S extends AliasedQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? ValueType<O> : never : S extends (qb: any) => AliasedQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? ValueType<O> : never : S extends DynamicReferenceBuilder<infer RA> ? A extends ExtractAliasFromStringSelectExpression<RA> ? ExtractTypeFromStringSelectExpression<DB, TB, RA, A> | undefined : never : never;
 declare type ExtractTypeFromStringSelectExpression<DB, TB extends keyof DB, S extends string, A extends keyof any, R = RowType<DB, TB>> = S extends `${infer SC}.${infer T}.${infer C} as ${infer RA}` ? RA extends A ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : never : S extends `${infer T}.${infer C} as ${infer RA}` ? RA extends A ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : never : S extends `${infer C} as ${infer RA}` ? RA extends A ? C extends keyof R ? R[C] : never : never : S extends `${infer SC}.${infer T}.${infer C}` ? C extends A ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : never : S extends `${infer T}.${infer C}` ? C extends A ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : never : S extends A ? S extends keyof R ? R[S] : never : never;
 export declare function parseSelectExpressionOrList(ctx: ParseContext, selection: SelectExpressionOrList<any, any>): SelectionNode[];
-export declare function parseSelectAllArgs(table?: string | string[]): SelectionNode[];
-export declare function parseSelectAllArg(table: string): SelectionNode;
+export declare function parseSelectAll(table?: string | string[]): SelectionNode[];
 export {};

package/dist/cjs/parser/select-parser.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseSelectAllArg = exports.parseSelectAllArgs = exports.parseSelectExpressionOrList = void 0;
+exports.parseSelectAll = exports.parseSelectExpressionOrList = void 0;
 const operation_node_source_js_1 = require("../operation-node/operation-node-source.js");
 const object_utils_js_1 = require("../util/object-utils.js");
 const selection_node_js_1 = require("../operation-node/selection-node.js");
@@ -22,13 +22,13 @@ function parseSelectExpression(ctx, selection) {
         return selection_node_js_1.SelectionNode.create(selection.toOperationNode());
     }
     else if ((0, object_utils_js_1.isFunction)(selection)) {
-        return selection_node_js_1.SelectionNode.create(selection(ctx.createSubQueryBuilder()).toOperationNode());
+        return selection_node_js_1.SelectionNode.create(selection(ctx.createExpressionBuilder()).toOperationNode());
     }
     else {
         throw new Error(`invalid value passed to select method: ${JSON.stringify(selection)}`);
     }
 }
-function parseSelectAllArgs(table) {
+function parseSelectAll(table) {
     if (!table) {
         return [selection_node_js_1.SelectionNode.createSelectAll()];
     }
@@ -39,7 +39,7 @@ function parseSelectAllArgs(table) {
         return [parseSelectAllArg(table)];
     }
 }
-exports.parseSelectAllArgs = parseSelectAllArgs;
+exports.parseSelectAll = parseSelectAll;
 function parseSelectAllArg(table) {
     if ((0, object_utils_js_1.isString)(table)) {
         return selection_node_js_1.SelectionNode.createSelectAllFromTable(table);
@@ -48,4 +48,3 @@ function parseSelectAllArg(table) {
         throw new Error(`invalid value passed to selectAll method: ${JSON.stringify(table)}`);
     }
 }
-exports.parseSelectAllArg = parseSelectAllArg;

package/dist/cjs/parser/table-parser.js

@@ -22,7 +22,7 @@ function parseTableExpression(ctx, table) {
         return table.toOperationNode();
     }
     else if ((0, object_utils_js_1.isFunction)(table)) {
-        return table(ctx.createSubQueryBuilder()).toOperationNode();
+        return table(ctx.createExpressionBuilder()).toOperationNode();
     }
     else {
         throw new Error(`invalid table expression ${JSON.stringify(table)}`);
@@ -30,18 +30,20 @@ function parseTableExpression(ctx, table) {
 }
 exports.parseTableExpression = parseTableExpression;
 function parseAliasedTable(from) {
-    const [table, alias] = from.split(' as ').map((it) => it.trim());
-    if (alias) {
+    const ALIAS_SEPARATOR = ' as ';
+    if (from.includes(ALIAS_SEPARATOR)) {
+        const [table, alias] = from.split(ALIAS_SEPARATOR).map(trim);
         return alias_node_js_1.AliasNode.create(parseTable(table), alias);
     }
     else {
-        return parseTable(table);
+        return parseTable(from);
     }
 }
 exports.parseAliasedTable = parseAliasedTable;
 function parseTable(from) {
-    if (from.includes('.')) {
-        const [schema, table] = from.split('.').map((it) => it.trim());
+    const SCHEMA_SEPARATOR = '.';
+    if (from.includes(SCHEMA_SEPARATOR)) {
+        const [schema, table] = from.split(SCHEMA_SEPARATOR).map(trim);
         return table_node_js_1.TableNode.createWithSchema(schema, table);
     }
     else {
@@ -49,3 +51,6 @@ function parseTable(from) {
     }
 }
 exports.parseTable = parseTable;
+function trim(str) {
+    return str.trim();
+}

package/dist/cjs/parser/update-set-parser.js

@@ -24,7 +24,7 @@ function parseMutationValueExpression(ctx, value) {
         }
     }
     else if ((0, object_utils_js_1.isFunction)(value)) {
-        const node = value(ctx.createSubQueryBuilder()).toOperationNode();
+        const node = value(ctx.createExpressionBuilder()).toOperationNode();
         if (!query_node_js_1.QueryNode.isMutating(node)) {
             return node;
         }

package/dist/cjs/parser/value-parser.js

@@ -28,7 +28,7 @@ function parseValueExpression(ctx, arg) {
         }
     }
     else if ((0, object_utils_js_1.isFunction)(arg)) {
-        const node = arg(ctx.createSubQueryBuilder()).toOperationNode();
+        const node = arg(ctx.createExpressionBuilder()).toOperationNode();
         if (!query_node_js_1.QueryNode.isMutating(node)) {
             return node;
         }

package/dist/cjs/query-builder/{sub-query-builder.d.ts → expression-builder.d.ts}

@@ -1,9 +1,9 @@
 import { TableExpression, QueryBuilderWithTable } from '../parser/table-parser.js';
 import { NoopQueryExecutor } from '../query-executor/noop-query-executor.js';
-import { DialectAdapter } from '../index.js';
-export declare class SubQueryBuilder<DB, TB extends keyof DB> {
+import { ParseContext } from '../parser/parse-context.js';
+export declare class ExpressionBuilder<DB, TB extends keyof DB> {
     #private;
-    constructor(props: SubQueryBuilderProps);
+    constructor(props: ExpressionBuilderProps);
     /**
      * Creates a subquery.
      *
@@ -50,9 +50,9 @@ export declare class SubQueryBuilder<DB, TB extends keyof DB> {
     /**
      * See {@link QueryCreator.withSchema}
      */
-    withSchema(schema: string): SubQueryBuilder<DB, TB>;
+    withSchema(schema: string): ExpressionBuilder<DB, TB>;
 }
-export interface SubQueryBuilderProps {
-    executor: NoopQueryExecutor;
-    adapter: DialectAdapter;
+export interface ExpressionBuilderProps {
+    readonly executor: NoopQueryExecutor;
+    readonly parseContext: ParseContext;
 }

package/dist/cjs/query-builder/{sub-query-builder.js → expression-builder.js}

@@ -1,14 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SubQueryBuilder = void 0;
+exports.ExpressionBuilder = void 0;
 const query_builder_js_1 = require("./query-builder.js");
 const select_query_node_js_1 = require("../operation-node/select-query-node.js");
 const table_parser_js_1 = require("../parser/table-parser.js");
 const with_schema_plugin_js_1 = require("../plugin/with-schema/with-schema-plugin.js");
 const query_id_js_1 = require("../util/query-id.js");
 const object_utils_js_1 = require("../util/object-utils.js");
-const parse_context_js_1 = require("../parser/parse-context.js");
-class SubQueryBuilder {
+class ExpressionBuilder {
     #props;
     constructor(props) {
         this.#props = (0, object_utils_js_1.freeze)(props);
@@ -17,21 +16,18 @@ class SubQueryBuilder {
         return new query_builder_js_1.QueryBuilder({
             queryId: (0, query_id_js_1.createQueryId)(),
             executor: this.#props.executor,
-            adapter: this.#props.adapter,
-            queryNode: select_query_node_js_1.SelectQueryNode.create((0, table_parser_js_1.parseTableExpressionOrList)(this.#parseContext, table)),
+            parseContext: this.#props.parseContext,
+            queryNode: select_query_node_js_1.SelectQueryNode.create((0, table_parser_js_1.parseTableExpressionOrList)(this.#props.parseContext, table)),
         });
     }
     /**
      * See {@link QueryCreator.withSchema}
      */
     withSchema(schema) {
-        return new SubQueryBuilder({
+        return new ExpressionBuilder({
             ...this.#props,
             executor: this.#props.executor.withPluginAtFront(new with_schema_plugin_js_1.WithSchemaPlugin(schema)),
         });
     }
-    get #parseContext() {
-        return (0, parse_context_js_1.createParseContext)(this.#props.adapter);
-    }
 }
-exports.SubQueryBuilder = SubQueryBuilder;
+exports.ExpressionBuilder = ExpressionBuilder;

package/dist/cjs/query-builder/join-builder.d.ts

@@ -1,7 +1,7 @@
-import { DialectAdapter } from '../dialect/dialect-adapter.js';
 import { JoinNode } from '../operation-node/join-node.js';
 import { OperationNodeSource } from '../operation-node/operation-node-source.js';
 import { ExistsExpression, FilterOperator } from '../parser/filter-parser.js';
+import { ParseContext } from '../parser/parse-context.js';
 import { ReferenceExpression } from '../parser/reference-parser.js';
 import { ValueExpressionOrList } from '../parser/value-parser.js';
 export declare class JoinBuilder<DB, TB extends keyof DB> implements OperationNodeSource {
@@ -69,5 +69,5 @@ export declare class JoinBuilder<DB, TB extends keyof DB> implements OperationNo
 }
 export interface JoinBuilderProps {
     readonly joinNode: JoinNode;
-    readonly adapter: DialectAdapter;
+    readonly parseContext: ParseContext;
 }

package/dist/cjs/query-builder/join-builder.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.JoinBuilder = void 0;
 const join_node_js_1 = require("../operation-node/join-node.js");
 const filter_parser_js_1 = require("../parser/filter-parser.js");
-const parse_context_js_1 = require("../parser/parse-context.js");
 const object_utils_js_1 = require("../util/object-utils.js");
 const prevent_await_js_1 = require("../util/prevent-await.js");
 class JoinBuilder {
@@ -14,13 +13,13 @@ class JoinBuilder {
     on(...args) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: join_node_js_1.JoinNode.cloneWithOn(this.#props.joinNode, 'And', (0, filter_parser_js_1.parseOnFilter)(this.#parseContext, args)),
+            joinNode: join_node_js_1.JoinNode.cloneWithOn(this.#props.joinNode, 'And', (0, filter_parser_js_1.parseOnFilter)(this.#props.parseContext, args)),
         });
     }
     orOn(...args) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: join_node_js_1.JoinNode.cloneWithOn(this.#props.joinNode, 'Or', (0, filter_parser_js_1.parseOnFilter)(this.#parseContext, args)),
+            joinNode: join_node_js_1.JoinNode.cloneWithOn(this.#props.joinNode, 'Or', (0, filter_parser_js_1.parseOnFilter)(this.#props.parseContext, args)),
         });
     }
     /**
@@ -32,7 +31,7 @@ class JoinBuilder {
     onRef(lhs, op, rhs) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: join_node_js_1.JoinNode.cloneWithOn(this.#props.joinNode, 'And', (0, filter_parser_js_1.parseReferenceFilter)(this.#parseContext, lhs, op, rhs)),
+            joinNode: join_node_js_1.JoinNode.cloneWithOn(this.#props.joinNode, 'And', (0, filter_parser_js_1.parseReferenceFilter)(this.#props.parseContext, lhs, op, rhs)),
         });
     }
     /**
@@ -44,7 +43,7 @@ class JoinBuilder {
     orOnRef(lhs, op, rhs) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: join_node_js_1.JoinNode.cloneWithOn(this.#props.joinNode, 'Or', (0, filter_parser_js_1.parseReferenceFilter)(this.#parseContext, lhs, op, rhs)),
+            joinNode: join_node_js_1.JoinNode.cloneWithOn(this.#props.joinNode, 'Or', (0, filter_parser_js_1.parseReferenceFilter)(this.#props.parseContext, lhs, op, rhs)),
         });
     }
     /**
@@ -56,7 +55,7 @@ class JoinBuilder {
     onExists(arg) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: join_node_js_1.JoinNode.cloneWithOn(this.#props.joinNode, 'And', (0, filter_parser_js_1.parseExistExpression)(this.#parseContext, arg)),
+            joinNode: join_node_js_1.JoinNode.cloneWithOn(this.#props.joinNode, 'And', (0, filter_parser_js_1.parseExistFilter)(this.#props.parseContext, arg)),
         });
     }
     /**
@@ -68,7 +67,7 @@ class JoinBuilder {
     onNotExists(arg) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: join_node_js_1.JoinNode.cloneWithOn(this.#props.joinNode, 'And', (0, filter_parser_js_1.parseNotExistExpression)(this.#parseContext, arg)),
+            joinNode: join_node_js_1.JoinNode.cloneWithOn(this.#props.joinNode, 'And', (0, filter_parser_js_1.parseNotExistFilter)(this.#props.parseContext, arg)),
         });
     }
     /**
@@ -80,7 +79,7 @@ class JoinBuilder {
     orOnExists(arg) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: join_node_js_1.JoinNode.cloneWithOn(this.#props.joinNode, 'Or', (0, filter_parser_js_1.parseExistExpression)(this.#parseContext, arg)),
+            joinNode: join_node_js_1.JoinNode.cloneWithOn(this.#props.joinNode, 'Or', (0, filter_parser_js_1.parseExistFilter)(this.#props.parseContext, arg)),
         });
     }
     /**
@@ -92,15 +91,12 @@ class JoinBuilder {
     orOnNotExists(arg) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: join_node_js_1.JoinNode.cloneWithOn(this.#props.joinNode, 'Or', (0, filter_parser_js_1.parseNotExistExpression)(this.#parseContext, arg)),
+            joinNode: join_node_js_1.JoinNode.cloneWithOn(this.#props.joinNode, 'Or', (0, filter_parser_js_1.parseNotExistFilter)(this.#props.parseContext, arg)),
         });
     }
     toOperationNode() {
         return this.#props.joinNode;
     }
-    get #parseContext() {
-        return (0, parse_context_js_1.createParseContext)(this.#props.adapter);
-    }
 }
 exports.JoinBuilder = JoinBuilder;
 (0, prevent_await_js_1.preventAwait)(JoinBuilder, "don't await JoinBuilder instances. They are never executed directly and are always just a part of a query.");

package/dist/cjs/query-builder/query-builder.d.ts

@@ -18,7 +18,7 @@ import { Compilable } from '../util/compilable.js';
 import { QueryExecutor } from '../query-executor/query-executor.js';
 import { QueryId } from '../util/query-id.js';
 import { OnConflictConstraintTarget } from '../parser/on-conflict-parser.js';
-import { DialectAdapter } from '../index.js';
+import { ParseContext } from '../parser/parse-context.js';
 /**
  * The main query builder class.
  *
@@ -1010,9 +1010,9 @@ export declare class QueryBuilder<DB, TB extends keyof DB, O = {}> implements Op
      * database, calling `onConflictDoNothing('name')` will ignore the conflict
      * and do nothing. By default the query would throw.
      *
-     * This method generates different SQL on different dialects. For example
-     * `insert ignore` is used on mysql and `on conflict (columns) do nothing`
-     * on postgres and sqlite.
+     * Only some dialects like postgres and sqlite implement the `on conflict`
+     * statement. On MySQL you should use the {@link ignore} method to achieve
+     * similar results.
      *
      * Also see the {@link QueryBuilder.onConflictUpdate | onConflictUpdate}
      * method if you want to perform an update in case of a conflict (upsert).
@@ -1067,6 +1067,27 @@ export declare class QueryBuilder<DB, TB extends keyof DB, O = {}> implements Op
     onConflictDoNothing(column: AnyColumn<DB, TB>): QueryBuilder<DB, TB, O>;
     onConflictDoNothing(columns: ReadonlyArray<AnyColumn<DB, TB>>): QueryBuilder<DB, TB, O>;
     onConflictDoNothing(constraint: OnConflictConstraintTarget): QueryBuilder<DB, TB, O>;
+    /**
+     * Changes an `insert into` query to an `insert ignore into` query.
+     *
+     * If you use the ignore modifier, ignorable errors that occur while executing the
+     * insert statement are ignored. For example, without ignore, a row that duplicates
+     * an existing unique index or primary key value in the table causes a duplicate-key
+     * error and the statement is aborted. With ignore, the row is discarded and no error
+     * occurs.
+     *
+     * This is only supported on some dialects like MySQL. On most dialects you should
+     * use the {@link onConflictDoNothing} method.
+     *
+     * @example
+     * ```ts
+     * await db.insertInto('person')
+     *   .ignore()
+     *   .values(values)
+     *   .execute()
+     * ```
+     */
+    ignore(): QueryBuilder<DB, TB, O>;
     /**
      * Ignores an insert if the column or constraint given as the first
      * argument conflicts with the current rows in the database and
@@ -1082,9 +1103,9 @@ export declare class QueryBuilder<DB, TB extends keyof DB, O = {}> implements Op
      * The second argument (updates) can be anything the {@link QueryBuilder.set | set}
      * method accepts.
      *
-     * This method generates different SQL on different dialects. For example
-     * `on duplicate key update` is used on mysql and `on conflict (columns) do update`
-     * on postgres and sqlite.
+     * The `on conflict do update` statement is only implemented by some dialects
+     * like postgres and sqlite. On MySQL you should use the {@link onDuplicateKeyUpdate}
+     * method instead.
      *
      * Also see the {@link QueryBuilder.onConflictDoNothing | onConflictDoNothing}
      * method.
@@ -1140,6 +1161,24 @@ export declare class QueryBuilder<DB, TB extends keyof DB, O = {}> implements Op
     onConflictUpdate(column: AnyColumn<DB, TB>, updates: MutationObject<DB, TB>): QueryBuilder<DB, TB, O>;
     onConflictUpdate(columns: ReadonlyArray<AnyColumn<DB, TB>>, updates: MutationObject<DB, TB>): QueryBuilder<DB, TB, O>;
     onConflictUpdate(constraint: OnConflictConstraintTarget, updates: MutationObject<DB, TB>): QueryBuilder<DB, TB, O>;
+    /**
+     * Adds `on duplicate key update` to an insert query.
+     *
+     * If you specify `on duplicate key update`, and a row is inserted that would cause
+     * a duplicate value in a unique index or primary key, an update of the old row occurs.
+     *
+     * This is only implemented by some dialects like MySQL. On most dialects you should
+     * use {@link onConflictUpdate} instead.
+     *
+     * @example
+     * ```ts
+     * await db
+     *   .insertInto('person')
+     *   .values(values)
+     *   .onDuplicateKeyUpdate({ species: 'hamster' })
+     * ```
+     */
+    onDuplicateKeyUpdate(updates: MutationObject<DB, TB>): QueryBuilder<DB, TB, O>;
     /**
      * Sets the values to update for an {@link Kysely.updateTable | update} query.
      *
@@ -1566,7 +1605,7 @@ export interface QueryBuilderProps {
     readonly queryId: QueryId;
     readonly queryNode: QueryNode;
     readonly executor: QueryExecutor;
-    readonly adapter: DialectAdapter;
+    readonly parseContext: ParseContext;
 }
 /**
  * {@link QueryBuilder} with an alias. The result of calling {@link QueryBuilder.as}.