kysely 0.7.1 → 0.7.5

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

@@ -1,7 +1,7 @@
 import { AliasNode } from '../operation-node/alias-node.js';
-import { parseJoinArgs, } from '../parser/join-parser.js';
-import { parseSelectExpressionOrList, parseSelectAllArgs, } from '../parser/select-parser.js';
-import { parseExistExpression, parseReferenceFilter, parseWhereFilter, parseHavingFilter, parseNotExistExpression, } from '../parser/filter-parser.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';
 import { parseInsertObjectOrList, } from '../parser/insert-values-parser.js';
 import { parseReferenceExpression, parseReferenceExpressionOrList, } from '../parser/reference-parser.js';
 import { OrderByItemNode, } from '../operation-node/order-by-item-node.js';
@@ -15,9 +15,9 @@ import { preventAwait } from '../util/prevent-await.js';
 import { LimitNode } from '../operation-node/limit-node.js';
 import { OffsetNode } from '../operation-node/offset-node.js';
 import { parseOnConflictDoNothing, parseOnConflictUpdate, } from '../parser/on-conflict-parser.js';
-import { DeleteQueryNode } from '../index.js';
 import { freeze } from '../util/object-utils.js';
-import { createParseContext } from '../parser/parse-context.js';
+import { DeleteQueryNode } from '../operation-node/delete-query-node.js';
+import { OnDuplicateKeyNode } from '../operation-node/on-duplicate-key-node.js';
 /**
  * The main query builder class.
  *
@@ -39,10 +39,10 @@ export class QueryBuilder {
         this.#props = freeze(props);
     }
     where(...args) {
-        ensureCanHaveWhereClause(this.#props.queryNode);
+        assertCanHaveWhereClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, 'And', parseWhereFilter(this.#parseContext, args)),
+            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, 'And', parseWhereFilter(this.#props.parseContext, args)),
         });
     }
     /**
@@ -97,17 +97,17 @@ export class QueryBuilder {
      * from "person"
      */
     whereRef(lhs, op, rhs) {
-        ensureCanHaveWhereClause(this.#props.queryNode);
+        assertCanHaveWhereClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, 'And', parseReferenceFilter(this.#parseContext, lhs, op, rhs)),
+            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, 'And', parseReferenceFilter(this.#props.parseContext, lhs, op, rhs)),
         });
     }
     orWhere(...args) {
-        ensureCanHaveWhereClause(this.#props.queryNode);
+        assertCanHaveWhereClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, 'Or', parseWhereFilter(this.#parseContext, args)),
+            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, 'Or', parseWhereFilter(this.#props.parseContext, args)),
         });
     }
     /**
@@ -117,10 +117,10 @@ export class QueryBuilder {
      * Also see {@link QueryBuilder.orWhere | orWhere} and {@link QueryBuilder.where | where}.
      */
     orWhereRef(lhs, op, rhs) {
-        ensureCanHaveWhereClause(this.#props.queryNode);
+        assertCanHaveWhereClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, 'Or', parseReferenceFilter(this.#parseContext, lhs, op, rhs)),
+            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, 'Or', parseReferenceFilter(this.#props.parseContext, lhs, op, rhs)),
         });
     }
     /**
@@ -183,47 +183,47 @@ export class QueryBuilder {
      * ```
      */
     whereExists(arg) {
-        ensureCanHaveWhereClause(this.#props.queryNode);
+        assertCanHaveWhereClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, 'And', parseExistExpression(this.#parseContext, arg)),
+            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, 'And', parseExistFilter(this.#props.parseContext, arg)),
         });
     }
     /**
      * Just like {@link QueryBuilder.whereExists | whereExists} but creates a `not exists` clause.
      */
     whereNotExists(arg) {
-        ensureCanHaveWhereClause(this.#props.queryNode);
+        assertCanHaveWhereClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, 'And', parseNotExistExpression(this.#parseContext, arg)),
+            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, 'And', parseNotExistFilter(this.#props.parseContext, arg)),
         });
     }
     /**
      * Just like {@link QueryBuilder.whereExists | whereExists} but creates a `or exists` clause.
      */
     orWhereExists(arg) {
-        ensureCanHaveWhereClause(this.#props.queryNode);
+        assertCanHaveWhereClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, 'Or', parseExistExpression(this.#parseContext, arg)),
+            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, 'Or', parseExistFilter(this.#props.parseContext, arg)),
         });
     }
     /**
      * Just like {@link QueryBuilder.whereExists | whereExists} but creates a `or not exists` clause.
      */
     orWhereNotExists(arg) {
-        ensureCanHaveWhereClause(this.#props.queryNode);
+        assertCanHaveWhereClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, 'Or', parseNotExistExpression(this.#parseContext, arg)),
+            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, 'Or', parseNotExistFilter(this.#props.parseContext, arg)),
         });
     }
     having(...args) {
-        ensureCanHaveHavingClause(this.#props.queryNode);
+        assertCanHaveHavingClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'And', parseHavingFilter(this.#parseContext, args)),
+            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'And', parseHavingFilter(this.#props.parseContext, args)),
         });
     }
     /**
@@ -231,17 +231,17 @@ export class QueryBuilder {
      * instead of a `where` statement.
      */
     havingRef(lhs, op, rhs) {
-        ensureCanHaveHavingClause(this.#props.queryNode);
+        assertCanHaveHavingClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'And', parseReferenceFilter(this.#parseContext, lhs, op, rhs)),
+            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'And', parseReferenceFilter(this.#props.parseContext, lhs, op, rhs)),
         });
     }
     orHaving(...args) {
-        ensureCanHaveHavingClause(this.#props.queryNode);
+        assertCanHaveHavingClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'Or', parseHavingFilter(this.#parseContext, args)),
+            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'Or', parseHavingFilter(this.#props.parseContext, args)),
         });
     }
     /**
@@ -249,10 +249,10 @@ export class QueryBuilder {
      * instead of a `where` statement.
      */
     orHavingRef(lhs, op, rhs) {
-        ensureCanHaveHavingClause(this.#props.queryNode);
+        assertCanHaveHavingClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'Or', parseReferenceFilter(this.#parseContext, lhs, op, rhs)),
+            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'Or', parseReferenceFilter(this.#props.parseContext, lhs, op, rhs)),
         });
     }
     /**
@@ -260,10 +260,10 @@ export class QueryBuilder {
      * instead of a `where` statement.
      */
     havingExists(arg) {
-        ensureCanHaveHavingClause(this.#props.queryNode);
+        assertCanHaveHavingClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'And', parseExistExpression(this.#parseContext, arg)),
+            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'And', parseExistFilter(this.#props.parseContext, arg)),
         });
     }
     /**
@@ -271,10 +271,10 @@ export class QueryBuilder {
      * instead of a `where` statement.
      */
     havingNotExist(arg) {
-        ensureCanHaveHavingClause(this.#props.queryNode);
+        assertCanHaveHavingClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'And', parseNotExistExpression(this.#parseContext, arg)),
+            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'And', parseNotExistFilter(this.#props.parseContext, arg)),
         });
     }
     /**
@@ -282,10 +282,10 @@ export class QueryBuilder {
      * instead of a `where` statement.
      */
     orHavingExists(arg) {
-        ensureCanHaveHavingClause(this.#props.queryNode);
+        assertCanHaveHavingClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'Or', parseExistExpression(this.#parseContext, arg)),
+            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'Or', parseExistFilter(this.#props.parseContext, arg)),
         });
     }
     /**
@@ -293,24 +293,24 @@ export class QueryBuilder {
      * instead of a `where` statement.
      */
     orHavingNotExists(arg) {
-        ensureCanHaveHavingClause(this.#props.queryNode);
+        assertCanHaveHavingClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'Or', parseNotExistExpression(this.#parseContext, arg)),
+            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'Or', parseNotExistFilter(this.#props.parseContext, arg)),
         });
     }
     select(selection) {
-        ensureCanHaveSelectClause(this.#props.queryNode);
+        assertCanHaveSelectClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithSelections(this.#props.queryNode, parseSelectExpressionOrList(this.#parseContext, selection)),
+            queryNode: SelectQueryNode.cloneWithSelections(this.#props.queryNode, parseSelectExpressionOrList(this.#props.parseContext, selection)),
         });
     }
     distinctOn(selection) {
-        ensureCanHaveSelectClause(this.#props.queryNode);
+        assertCanHaveSelectClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithDistinctOnSelections(this.#props.queryNode, parseSelectExpressionOrList(this.#parseContext, selection)),
+            queryNode: SelectQueryNode.cloneWithDistinctOnSelections(this.#props.queryNode, parseSelectExpressionOrList(this.#props.parseContext, selection)),
         });
     }
     /**
@@ -331,7 +331,7 @@ export class QueryBuilder {
      * ```
      */
     distinct() {
-        ensureCanHaveSelectClause(this.#props.queryNode);
+        assertCanHaveSelectClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
             queryNode: SelectQueryNode.cloneWithDistinct(this.#props.queryNode),
@@ -341,7 +341,7 @@ export class QueryBuilder {
      * Adds the `for update` option to a select query on supported databases.
      */
     forUpdate() {
-        ensureCanHaveSelectClause(this.#props.queryNode);
+        assertCanHaveSelectClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
             queryNode: SelectQueryNode.cloneWithModifier(this.#props.queryNode, 'ForUpdate'),
@@ -351,7 +351,7 @@ export class QueryBuilder {
      * Adds the `for share` option to a select query on supported databases.
      */
     forShare() {
-        ensureCanHaveSelectClause(this.#props.queryNode);
+        assertCanHaveSelectClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
             queryNode: SelectQueryNode.cloneWithModifier(this.#props.queryNode, 'ForShare'),
@@ -361,7 +361,7 @@ export class QueryBuilder {
      * Adds the `for key share` option to a select query on supported databases.
      */
     forKeyShare() {
-        ensureCanHaveSelectClause(this.#props.queryNode);
+        assertCanHaveSelectClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
             queryNode: SelectQueryNode.cloneWithModifier(this.#props.queryNode, 'ForKeyShare'),
@@ -371,7 +371,7 @@ export class QueryBuilder {
      * Adds the `for no key update` option to a select query on supported databases.
      */
     forNoKeyUpdate() {
-        ensureCanHaveSelectClause(this.#props.queryNode);
+        assertCanHaveSelectClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
             queryNode: SelectQueryNode.cloneWithModifier(this.#props.queryNode, 'ForNoKeyUpdate'),
@@ -381,7 +381,7 @@ export class QueryBuilder {
      * Adds the `skip locked` option to a select query on supported databases.
      */
     skipLocked() {
-        ensureCanHaveSelectClause(this.#props.queryNode);
+        assertCanHaveSelectClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
             queryNode: SelectQueryNode.cloneWithModifier(this.#props.queryNode, 'SkipLocked'),
@@ -391,66 +391,129 @@ export class QueryBuilder {
      * Adds the `nowait` option to a select query on supported databases.
      */
     noWait() {
-        ensureCanHaveSelectClause(this.#props.queryNode);
+        assertCanHaveSelectClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
             queryNode: SelectQueryNode.cloneWithModifier(this.#props.queryNode, 'NoWait'),
         });
     }
     selectAll(table) {
-        ensureCanHaveSelectClause(this.#props.queryNode);
+        assertCanHaveSelectClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithSelections(this.#props.queryNode, parseSelectAllArgs(table)),
+            queryNode: SelectQueryNode.cloneWithSelections(this.#props.queryNode, parseSelectAll(table)),
         });
     }
     innerJoin(...args) {
-        ensureCanHaveJoins(this.#props.queryNode);
+        assertCanHaveJoins(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoinArgs(this.#parseContext, 'InnerJoin', args)),
+            queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoin(this.#props.parseContext, 'InnerJoin', args)),
         });
     }
     leftJoin(...args) {
-        ensureCanHaveJoins(this.#props.queryNode);
+        assertCanHaveJoins(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoinArgs(this.#parseContext, 'LeftJoin', args)),
+            queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoin(this.#props.parseContext, 'LeftJoin', args)),
         });
     }
     rightJoin(...args) {
-        ensureCanHaveJoins(this.#props.queryNode);
+        assertCanHaveJoins(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoinArgs(this.#parseContext, 'RightJoin', args)),
+            queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoin(this.#props.parseContext, 'RightJoin', args)),
         });
     }
     fullJoin(...args) {
-        ensureCanHaveJoins(this.#props.queryNode);
+        assertCanHaveJoins(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoinArgs(this.#parseContext, 'FullJoin', args)),
+            queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoin(this.#props.parseContext, 'FullJoin', args)),
         });
     }
     values(args) {
-        ensureCanHaveInsertValues(this.#props.queryNode);
+        assertCanHaveInsertValues(this.#props.queryNode);
+        const [columns, values] = parseInsertObjectOrList(args);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: InsertQueryNode.cloneWithColumnsAndValues(this.#props.queryNode, ...parseInsertObjectOrList(args)),
+            queryNode: InsertQueryNode.cloneWith(this.#props.queryNode, {
+                columns,
+                values,
+            }),
         });
     }
     onConflictDoNothing(target) {
-        ensureCanHaveOnConflict(this.#props.queryNode);
+        assertCanHaveOnConflict(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: InsertQueryNode.cloneWithOnConflict(this.#props.queryNode, parseOnConflictDoNothing(target)),
+            queryNode: InsertQueryNode.cloneWith(this.#props.queryNode, {
+                onConflict: parseOnConflictDoNothing(target),
+            }),
+        });
+    }
+    /**
+     * 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() {
+        assertCanHaveInsertIgnore(this.#props.queryNode);
+        return new QueryBuilder({
+            ...this.#props,
+            queryNode: InsertQueryNode.cloneWith(this.#props.queryNode, {
+                ignore: true,
+            }),
         });
     }
     onConflictUpdate(target, updates) {
-        ensureCanHaveOnConflict(this.#props.queryNode);
+        assertCanHaveOnConflict(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: InsertQueryNode.cloneWithOnConflict(this.#props.queryNode, parseOnConflictUpdate(this.#parseContext, target, updates)),
+            queryNode: InsertQueryNode.cloneWith(this.#props.queryNode, {
+                onConflict: parseOnConflictUpdate(this.#props.parseContext, target, updates),
+            }),
+        });
+    }
+    /**
+     * 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) {
+        assertCanHaveOnDuplicateKey(this.#props.queryNode);
+        return new QueryBuilder({
+            ...this.#props,
+            queryNode: InsertQueryNode.cloneWith(this.#props.queryNode, {
+                onDuplicateKey: OnDuplicateKeyNode.create(parseUpdateObject(this.#props.parseContext, updates)),
+            }),
         });
     }
     /**
@@ -536,17 +599,17 @@ export class QueryBuilder {
      * ```
      */
     set(row) {
-        ensureCanHaveUpdates(this.#props.queryNode);
+        assertCanHaveUpdates(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: UpdateQueryNode.cloneWithUpdates(this.#props.queryNode, parseUpdateObject(this.#parseContext, row)),
+            queryNode: UpdateQueryNode.cloneWithUpdates(this.#props.queryNode, parseUpdateObject(this.#props.parseContext, row)),
         });
     }
     returning(selection) {
-        ensureCanHaveReturningClause(this.#props.queryNode);
+        assertCanHaveReturningClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithReturning(this.#props.queryNode, parseSelectExpressionOrList(this.#parseContext, selection)),
+            queryNode: QueryNode.cloneWithReturning(this.#props.queryNode, parseSelectExpressionOrList(this.#props.parseContext, selection)),
         });
     }
     /**
@@ -554,10 +617,10 @@ export class QueryBuilder {
      * that support `returning` such as postgres.
      */
     returningAll() {
-        ensureCanHaveReturningClause(this.#props.queryNode);
+        assertCanHaveReturningClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithReturning(this.#props.queryNode, parseSelectAllArgs()),
+            queryNode: QueryNode.cloneWithReturning(this.#props.queryNode, parseSelectAll()),
         });
     }
     /**
@@ -647,17 +710,17 @@ export class QueryBuilder {
      * ```
      */
     orderBy(orderBy, direction = 'asc') {
-        ensureCanHaveOrderByClause(this.#props.queryNode);
+        assertCanHaveOrderByClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithOrderByItem(this.#props.queryNode, OrderByItemNode.create(parseReferenceExpression(this.#parseContext, orderBy), direction)),
+            queryNode: SelectQueryNode.cloneWithOrderByItem(this.#props.queryNode, OrderByItemNode.create(parseReferenceExpression(this.#props.parseContext, orderBy), direction)),
         });
     }
     groupBy(orderBy) {
-        ensureCanHaveGroupByClause(this.#props.queryNode);
+        assertCanHaveGroupByClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithGroupByItems(this.#props.queryNode, parseReferenceExpressionOrList(this.#parseContext, orderBy).map(GroupByItemNode.create)),
+            queryNode: SelectQueryNode.cloneWithGroupByItems(this.#props.queryNode, parseReferenceExpressionOrList(this.#props.parseContext, orderBy).map(GroupByItemNode.create)),
         });
     }
     /**
@@ -685,7 +748,7 @@ export class QueryBuilder {
      * ```
      */
     limit(limit) {
-        ensureCanHaveLimit(this.#props.queryNode);
+        assertCanHaveLimit(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
             queryNode: SelectQueryNode.cloneWithLimit(this.#props.queryNode, LimitNode.create(limit)),
@@ -706,7 +769,7 @@ export class QueryBuilder {
      * ```
      */
     offset(offset) {
-        ensureCanHaveOffset(this.#props.queryNode);
+        assertCanHaveOffset(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
             queryNode: SelectQueryNode.cloneWithOffset(this.#props.queryNode, OffsetNode.create(offset)),
@@ -756,7 +819,8 @@ export class QueryBuilder {
         const compildQuery = this.#props.executor.compileQuery(node, this.#props.queryId);
         const result = await this.#props.executor.executeQuery(compildQuery, this.#props.queryId);
         if (InsertQueryNode.is(node)) {
-            if (this.#props.adapter.supportsReturning && node.returning) {
+            if (this.#props.parseContext.adapter.supportsReturning &&
+                node.returning) {
                 return result.rows;
             }
             else if (result.insertedPrimaryKey != null) {
@@ -767,7 +831,8 @@ export class QueryBuilder {
             }
         }
         else if (UpdateQueryNode.is(node) || DeleteQueryNode.is(node)) {
-            if (this.#props.adapter.supportsReturning && node.returning) {
+            if (this.#props.parseContext.adapter.supportsReturning &&
+                node.returning) {
                 return result.rows;
             }
             else if (result.numUpdatedOrDeletedRows != null) {
@@ -804,9 +869,6 @@ export class QueryBuilder {
         }
         return result;
     }
-    get #parseContext() {
-        return createParseContext(this.#props.adapter);
-    }
 }
 preventAwait(QueryBuilder, "don't await QueryBuilder instances directly. To execute the query you need to call `execute` or `executeTakeFirst`.");
 /**
@@ -848,62 +910,72 @@ export class NoResultError extends Error {
         this.node = node;
     }
 }
-function ensureCanHaveWhereClause(node) {
+function assertCanHaveWhereClause(node) {
     if (!QueryNode.isFilterable(node)) {
         throw new Error('only select, delete and update queries can have a where clause');
     }
 }
-function ensureCanHaveHavingClause(node) {
+function assertCanHaveHavingClause(node) {
     if (!SelectQueryNode.is(node)) {
         throw new Error('only select queries can have a having clause');
     }
 }
-function ensureCanHaveSelectClause(node) {
+function assertCanHaveSelectClause(node) {
     if (!SelectQueryNode.is(node)) {
         throw new Error('only a select query can have selections');
     }
 }
-function ensureCanHaveJoins(node) {
+function assertCanHaveJoins(node) {
     if (!QueryNode.isFilterable(node)) {
         throw new Error('only select, delete and update queries can have joins');
     }
 }
-function ensureCanHaveInsertValues(node) {
+function assertCanHaveInsertValues(node) {
     if (!InsertQueryNode.is(node)) {
         throw new Error('only an insert query can have insert values');
     }
 }
-function ensureCanHaveOnConflict(node) {
+function assertCanHaveInsertIgnore(node) {
+    if (!InsertQueryNode.is(node)) {
+        throw new Error('only an insert query can have the ignore clause');
+    }
+}
+function assertCanHaveOnConflict(node) {
     if (!InsertQueryNode.is(node)) {
         throw new Error('only an insert query can have an on conflict clause');
     }
 }
-function ensureCanHaveUpdates(node) {
+function assertCanHaveOnDuplicateKey(node) {
+    if (!InsertQueryNode.is(node)) {
+        throw new Error('only an insert query can have an on duplicate key clause');
+    }
+}
+function assertCanHaveUpdates(node) {
     if (!UpdateQueryNode.is(node)) {
         throw new Error('only an update query can set values');
     }
 }
-function ensureCanHaveReturningClause(node) {
+function assertCanHaveReturningClause(node) {
     if (!QueryNode.isMutating(node)) {
         throw new Error('only an insert, delete and update queries can have a returning clause');
     }
 }
-function ensureCanHaveOrderByClause(node) {
+function assertCanHaveOrderByClause(node) {
     if (!SelectQueryNode.is(node)) {
         throw new Error('only a select query can have an order by clause');
     }
 }
-function ensureCanHaveGroupByClause(node) {
+function assertCanHaveGroupByClause(node) {
     if (!SelectQueryNode.is(node)) {
         throw new Error('only a select query can have a group by clause');
     }
 }
-function ensureCanHaveLimit(node) {
+function assertCanHaveLimit(node) {
     if (!SelectQueryNode.is(node)) {
         throw new Error('only a select query can have a limit');
     }
 }
-function ensureCanHaveOffset(node) {
+function assertCanHaveOffset(node) {
     if (!SelectQueryNode.is(node)) {
         throw new Error('only a select query can have an offset');
     }

package/dist/esm/query-builder/type-utils.d.ts

@@ -1,6 +1,6 @@
 import { AliasedRawBuilder, RawBuilder } from '../raw-builder/raw-builder.js';
 import { AliasedQueryBuilder, QueryBuilder } from './query-builder.js';
-import { SubQueryBuilder } from './sub-query-builder.js';
+import { ExpressionBuilder } from './expression-builder.js';
 export declare type ValueType<T> = T[keyof T];
 /**
  * Given a database type and a union of table names returns the row type
@@ -127,10 +127,10 @@ export declare type AnyQueryBuilder = QueryBuilder<any, any, any>;
 export declare type AnyAliasedQueryBuilder = AliasedQueryBuilder<any, any, any, any>;
 export declare type AnyRawBuilder = RawBuilder<any>;
 export declare type AnyAliasedRawBuilder = AliasedRawBuilder<any, any>;
-export declare type QueryBuilderFactory<DB, TB extends keyof DB> = (qb: SubQueryBuilder<DB, TB>) => QueryBuilder<any, any, any>;
-export declare type AliasedQueryBuilderFactory<DB, TB extends keyof DB> = (qb: SubQueryBuilder<DB, TB>) => AnyAliasedQueryBuilder;
-export declare type RawBuilderFactory<DB, TB extends keyof DB> = (qb: SubQueryBuilder<DB, TB>) => AnyRawBuilder;
-export declare type AliasedRawBuilderFactory<DB, TB extends keyof DB> = (qb: SubQueryBuilder<DB, TB>) => AnyAliasedRawBuilder;
+export declare type QueryBuilderFactory<DB, TB extends keyof DB> = (qb: ExpressionBuilder<DB, TB>) => QueryBuilder<any, any, any>;
+export declare type AliasedQueryBuilderFactory<DB, TB extends keyof DB> = (qb: ExpressionBuilder<DB, TB>) => AnyAliasedQueryBuilder;
+export declare type RawBuilderFactory<DB, TB extends keyof DB> = (qb: ExpressionBuilder<DB, TB>) => AnyRawBuilder;
+export declare type AliasedRawBuilderFactory<DB, TB extends keyof DB> = (qb: ExpressionBuilder<DB, TB>) => AnyAliasedRawBuilder;
 export interface InsertResultTypeTag {
     /** @internal */
     __isInsertResultTypeTag__: true;

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

@@ -59,6 +59,7 @@ import { DropConstraintNode } from '../operation-node/drop-constraint-node.js';
 import { ForeignKeyConstraintNode } from '../operation-node/foreign-key-constraint-node.js';
 import { ColumnDefinitionNode } from '../operation-node/column-definition-node.js';
 import { ModifyColumnNode } from '../operation-node/modify-column-node.js';
+import { OnDuplicateKeyNode } from '../operation-node/on-duplicate-key-node.js';
 export declare class DefaultQueryCompiler extends OperationNodeVisitor implements QueryCompiler {
     #private;
     protected get numBindings(): number;
@@ -71,7 +72,6 @@ export declare class DefaultQueryCompiler extends OperationNodeVisitor implement
     protected visitWhere(node: WhereNode): void;
     protected visitHaving(node: HavingNode): void;
     protected visitInsertQuery(node: InsertQueryNode): void;
-    protected getInsertInto(node: InsertQueryNode): string;
     protected visitDeleteQuery(node: DeleteQueryNode): void;
     protected visitReturning(node: ReturningNode): void;
     protected visitAlias(node: AliasNode): void;
@@ -104,6 +104,7 @@ export declare class DefaultQueryCompiler extends OperationNodeVisitor implement
     protected visitLimit(node: LimitNode): void;
     protected visitOffset(node: OffsetNode): void;
     protected visitOnConflict(node: OnConflictNode): void;
+    protected visitOnDuplicateKey(node: OnDuplicateKeyNode): void;
     protected visitCreateIndex(node: CreateIndexNode): void;
     protected visitDropIndex(node: DropIndexNode): void;
     protected visitCreateSchema(node: CreateSchemaNode): void;