kysely 0.7.1 → 0.7.5

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

@@ -18,9 +18,9 @@ const prevent_await_js_1 = require("../util/prevent-await.js");
 const limit_node_js_1 = require("../operation-node/limit-node.js");
 const offset_node_js_1 = require("../operation-node/offset-node.js");
 const on_conflict_parser_js_1 = require("../parser/on-conflict-parser.js");
-const index_js_1 = require("../index.js");
 const object_utils_js_1 = require("../util/object-utils.js");
-const parse_context_js_1 = require("../parser/parse-context.js");
+const delete_query_node_js_1 = require("../operation-node/delete-query-node.js");
+const on_duplicate_key_node_js_1 = require("../operation-node/on-duplicate-key-node.js");
 /**
  * The main query builder class.
  *
@@ -42,10 +42,10 @@ class QueryBuilder {
         this.#props = (0, object_utils_js_1.freeze)(props);
     }
     where(...args) {
-        ensureCanHaveWhereClause(this.#props.queryNode);
+        assertCanHaveWhereClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: query_node_js_1.QueryNode.cloneWithWhere(this.#props.queryNode, 'And', (0, filter_parser_js_1.parseWhereFilter)(this.#parseContext, args)),
+            queryNode: query_node_js_1.QueryNode.cloneWithWhere(this.#props.queryNode, 'And', (0, filter_parser_js_1.parseWhereFilter)(this.#props.parseContext, args)),
         });
     }
     /**
@@ -100,17 +100,17 @@ class QueryBuilder {
      * from "person"
      */
     whereRef(lhs, op, rhs) {
-        ensureCanHaveWhereClause(this.#props.queryNode);
+        assertCanHaveWhereClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: query_node_js_1.QueryNode.cloneWithWhere(this.#props.queryNode, 'And', (0, filter_parser_js_1.parseReferenceFilter)(this.#parseContext, lhs, op, rhs)),
+            queryNode: query_node_js_1.QueryNode.cloneWithWhere(this.#props.queryNode, 'And', (0, filter_parser_js_1.parseReferenceFilter)(this.#props.parseContext, lhs, op, rhs)),
         });
     }
     orWhere(...args) {
-        ensureCanHaveWhereClause(this.#props.queryNode);
+        assertCanHaveWhereClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: query_node_js_1.QueryNode.cloneWithWhere(this.#props.queryNode, 'Or', (0, filter_parser_js_1.parseWhereFilter)(this.#parseContext, args)),
+            queryNode: query_node_js_1.QueryNode.cloneWithWhere(this.#props.queryNode, 'Or', (0, filter_parser_js_1.parseWhereFilter)(this.#props.parseContext, args)),
         });
     }
     /**
@@ -120,10 +120,10 @@ 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: query_node_js_1.QueryNode.cloneWithWhere(this.#props.queryNode, 'Or', (0, filter_parser_js_1.parseReferenceFilter)(this.#parseContext, lhs, op, rhs)),
+            queryNode: query_node_js_1.QueryNode.cloneWithWhere(this.#props.queryNode, 'Or', (0, filter_parser_js_1.parseReferenceFilter)(this.#props.parseContext, lhs, op, rhs)),
         });
     }
     /**
@@ -186,47 +186,47 @@ class QueryBuilder {
      * ```
      */
     whereExists(arg) {
-        ensureCanHaveWhereClause(this.#props.queryNode);
+        assertCanHaveWhereClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: query_node_js_1.QueryNode.cloneWithWhere(this.#props.queryNode, 'And', (0, filter_parser_js_1.parseExistExpression)(this.#parseContext, arg)),
+            queryNode: query_node_js_1.QueryNode.cloneWithWhere(this.#props.queryNode, 'And', (0, filter_parser_js_1.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: query_node_js_1.QueryNode.cloneWithWhere(this.#props.queryNode, 'And', (0, filter_parser_js_1.parseNotExistExpression)(this.#parseContext, arg)),
+            queryNode: query_node_js_1.QueryNode.cloneWithWhere(this.#props.queryNode, 'And', (0, filter_parser_js_1.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: query_node_js_1.QueryNode.cloneWithWhere(this.#props.queryNode, 'Or', (0, filter_parser_js_1.parseExistExpression)(this.#parseContext, arg)),
+            queryNode: query_node_js_1.QueryNode.cloneWithWhere(this.#props.queryNode, 'Or', (0, filter_parser_js_1.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: query_node_js_1.QueryNode.cloneWithWhere(this.#props.queryNode, 'Or', (0, filter_parser_js_1.parseNotExistExpression)(this.#parseContext, arg)),
+            queryNode: query_node_js_1.QueryNode.cloneWithWhere(this.#props.queryNode, 'Or', (0, filter_parser_js_1.parseNotExistFilter)(this.#props.parseContext, arg)),
         });
     }
     having(...args) {
-        ensureCanHaveHavingClause(this.#props.queryNode);
+        assertCanHaveHavingClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'And', (0, filter_parser_js_1.parseHavingFilter)(this.#parseContext, args)),
+            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'And', (0, filter_parser_js_1.parseHavingFilter)(this.#props.parseContext, args)),
         });
     }
     /**
@@ -234,17 +234,17 @@ 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: select_query_node_js_1.SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'And', (0, filter_parser_js_1.parseReferenceFilter)(this.#parseContext, lhs, op, rhs)),
+            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'And', (0, filter_parser_js_1.parseReferenceFilter)(this.#props.parseContext, lhs, op, rhs)),
         });
     }
     orHaving(...args) {
-        ensureCanHaveHavingClause(this.#props.queryNode);
+        assertCanHaveHavingClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'Or', (0, filter_parser_js_1.parseHavingFilter)(this.#parseContext, args)),
+            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'Or', (0, filter_parser_js_1.parseHavingFilter)(this.#props.parseContext, args)),
         });
     }
     /**
@@ -252,10 +252,10 @@ 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: select_query_node_js_1.SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'Or', (0, filter_parser_js_1.parseReferenceFilter)(this.#parseContext, lhs, op, rhs)),
+            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'Or', (0, filter_parser_js_1.parseReferenceFilter)(this.#props.parseContext, lhs, op, rhs)),
         });
     }
     /**
@@ -263,10 +263,10 @@ class QueryBuilder {
      * instead of a `where` statement.
      */
     havingExists(arg) {
-        ensureCanHaveHavingClause(this.#props.queryNode);
+        assertCanHaveHavingClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'And', (0, filter_parser_js_1.parseExistExpression)(this.#parseContext, arg)),
+            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'And', (0, filter_parser_js_1.parseExistFilter)(this.#props.parseContext, arg)),
         });
     }
     /**
@@ -274,10 +274,10 @@ class QueryBuilder {
      * instead of a `where` statement.
      */
     havingNotExist(arg) {
-        ensureCanHaveHavingClause(this.#props.queryNode);
+        assertCanHaveHavingClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'And', (0, filter_parser_js_1.parseNotExistExpression)(this.#parseContext, arg)),
+            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'And', (0, filter_parser_js_1.parseNotExistFilter)(this.#props.parseContext, arg)),
         });
     }
     /**
@@ -285,10 +285,10 @@ class QueryBuilder {
      * instead of a `where` statement.
      */
     orHavingExists(arg) {
-        ensureCanHaveHavingClause(this.#props.queryNode);
+        assertCanHaveHavingClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'Or', (0, filter_parser_js_1.parseExistExpression)(this.#parseContext, arg)),
+            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'Or', (0, filter_parser_js_1.parseExistFilter)(this.#props.parseContext, arg)),
         });
     }
     /**
@@ -296,24 +296,24 @@ class QueryBuilder {
      * instead of a `where` statement.
      */
     orHavingNotExists(arg) {
-        ensureCanHaveHavingClause(this.#props.queryNode);
+        assertCanHaveHavingClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'Or', (0, filter_parser_js_1.parseNotExistExpression)(this.#parseContext, arg)),
+            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'Or', (0, filter_parser_js_1.parseNotExistFilter)(this.#props.parseContext, arg)),
         });
     }
     select(selection) {
-        ensureCanHaveSelectClause(this.#props.queryNode);
+        assertCanHaveSelectClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithSelections(this.#props.queryNode, (0, select_parser_js_1.parseSelectExpressionOrList)(this.#parseContext, selection)),
+            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithSelections(this.#props.queryNode, (0, select_parser_js_1.parseSelectExpressionOrList)(this.#props.parseContext, selection)),
         });
     }
     distinctOn(selection) {
-        ensureCanHaveSelectClause(this.#props.queryNode);
+        assertCanHaveSelectClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithDistinctOnSelections(this.#props.queryNode, (0, select_parser_js_1.parseSelectExpressionOrList)(this.#parseContext, selection)),
+            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithDistinctOnSelections(this.#props.queryNode, (0, select_parser_js_1.parseSelectExpressionOrList)(this.#props.parseContext, selection)),
         });
     }
     /**
@@ -334,7 +334,7 @@ class QueryBuilder {
      * ```
      */
     distinct() {
-        ensureCanHaveSelectClause(this.#props.queryNode);
+        assertCanHaveSelectClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
             queryNode: select_query_node_js_1.SelectQueryNode.cloneWithDistinct(this.#props.queryNode),
@@ -344,7 +344,7 @@ 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: select_query_node_js_1.SelectQueryNode.cloneWithModifier(this.#props.queryNode, 'ForUpdate'),
@@ -354,7 +354,7 @@ 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: select_query_node_js_1.SelectQueryNode.cloneWithModifier(this.#props.queryNode, 'ForShare'),
@@ -364,7 +364,7 @@ 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: select_query_node_js_1.SelectQueryNode.cloneWithModifier(this.#props.queryNode, 'ForKeyShare'),
@@ -374,7 +374,7 @@ 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: select_query_node_js_1.SelectQueryNode.cloneWithModifier(this.#props.queryNode, 'ForNoKeyUpdate'),
@@ -384,7 +384,7 @@ 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: select_query_node_js_1.SelectQueryNode.cloneWithModifier(this.#props.queryNode, 'SkipLocked'),
@@ -394,66 +394,129 @@ 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: select_query_node_js_1.SelectQueryNode.cloneWithModifier(this.#props.queryNode, 'NoWait'),
         });
     }
     selectAll(table) {
-        ensureCanHaveSelectClause(this.#props.queryNode);
+        assertCanHaveSelectClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithSelections(this.#props.queryNode, (0, select_parser_js_1.parseSelectAllArgs)(table)),
+            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithSelections(this.#props.queryNode, (0, select_parser_js_1.parseSelectAll)(table)),
         });
     }
     innerJoin(...args) {
-        ensureCanHaveJoins(this.#props.queryNode);
+        assertCanHaveJoins(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: query_node_js_1.QueryNode.cloneWithJoin(this.#props.queryNode, (0, join_parser_js_1.parseJoinArgs)(this.#parseContext, 'InnerJoin', args)),
+            queryNode: query_node_js_1.QueryNode.cloneWithJoin(this.#props.queryNode, (0, join_parser_js_1.parseJoin)(this.#props.parseContext, 'InnerJoin', args)),
         });
     }
     leftJoin(...args) {
-        ensureCanHaveJoins(this.#props.queryNode);
+        assertCanHaveJoins(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: query_node_js_1.QueryNode.cloneWithJoin(this.#props.queryNode, (0, join_parser_js_1.parseJoinArgs)(this.#parseContext, 'LeftJoin', args)),
+            queryNode: query_node_js_1.QueryNode.cloneWithJoin(this.#props.queryNode, (0, join_parser_js_1.parseJoin)(this.#props.parseContext, 'LeftJoin', args)),
         });
     }
     rightJoin(...args) {
-        ensureCanHaveJoins(this.#props.queryNode);
+        assertCanHaveJoins(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: query_node_js_1.QueryNode.cloneWithJoin(this.#props.queryNode, (0, join_parser_js_1.parseJoinArgs)(this.#parseContext, 'RightJoin', args)),
+            queryNode: query_node_js_1.QueryNode.cloneWithJoin(this.#props.queryNode, (0, join_parser_js_1.parseJoin)(this.#props.parseContext, 'RightJoin', args)),
         });
     }
     fullJoin(...args) {
-        ensureCanHaveJoins(this.#props.queryNode);
+        assertCanHaveJoins(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: query_node_js_1.QueryNode.cloneWithJoin(this.#props.queryNode, (0, join_parser_js_1.parseJoinArgs)(this.#parseContext, 'FullJoin', args)),
+            queryNode: query_node_js_1.QueryNode.cloneWithJoin(this.#props.queryNode, (0, join_parser_js_1.parseJoin)(this.#props.parseContext, 'FullJoin', args)),
         });
     }
     values(args) {
-        ensureCanHaveInsertValues(this.#props.queryNode);
+        assertCanHaveInsertValues(this.#props.queryNode);
+        const [columns, values] = (0, insert_values_parser_js_1.parseInsertObjectOrList)(args);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: insert_query_node_js_1.InsertQueryNode.cloneWithColumnsAndValues(this.#props.queryNode, ...(0, insert_values_parser_js_1.parseInsertObjectOrList)(args)),
+            queryNode: insert_query_node_js_1.InsertQueryNode.cloneWith(this.#props.queryNode, {
+                columns,
+                values,
+            }),
         });
     }
     onConflictDoNothing(target) {
-        ensureCanHaveOnConflict(this.#props.queryNode);
+        assertCanHaveOnConflict(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: insert_query_node_js_1.InsertQueryNode.cloneWithOnConflict(this.#props.queryNode, (0, on_conflict_parser_js_1.parseOnConflictDoNothing)(target)),
+            queryNode: insert_query_node_js_1.InsertQueryNode.cloneWith(this.#props.queryNode, {
+                onConflict: (0, on_conflict_parser_js_1.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: insert_query_node_js_1.InsertQueryNode.cloneWith(this.#props.queryNode, {
+                ignore: true,
+            }),
         });
     }
     onConflictUpdate(target, updates) {
-        ensureCanHaveOnConflict(this.#props.queryNode);
+        assertCanHaveOnConflict(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: insert_query_node_js_1.InsertQueryNode.cloneWithOnConflict(this.#props.queryNode, (0, on_conflict_parser_js_1.parseOnConflictUpdate)(this.#parseContext, target, updates)),
+            queryNode: insert_query_node_js_1.InsertQueryNode.cloneWith(this.#props.queryNode, {
+                onConflict: (0, on_conflict_parser_js_1.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: insert_query_node_js_1.InsertQueryNode.cloneWith(this.#props.queryNode, {
+                onDuplicateKey: on_duplicate_key_node_js_1.OnDuplicateKeyNode.create((0, update_set_parser_js_1.parseUpdateObject)(this.#props.parseContext, updates)),
+            }),
         });
     }
     /**
@@ -539,17 +602,17 @@ class QueryBuilder {
      * ```
      */
     set(row) {
-        ensureCanHaveUpdates(this.#props.queryNode);
+        assertCanHaveUpdates(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: update_query_node_js_1.UpdateQueryNode.cloneWithUpdates(this.#props.queryNode, (0, update_set_parser_js_1.parseUpdateObject)(this.#parseContext, row)),
+            queryNode: update_query_node_js_1.UpdateQueryNode.cloneWithUpdates(this.#props.queryNode, (0, update_set_parser_js_1.parseUpdateObject)(this.#props.parseContext, row)),
         });
     }
     returning(selection) {
-        ensureCanHaveReturningClause(this.#props.queryNode);
+        assertCanHaveReturningClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: query_node_js_1.QueryNode.cloneWithReturning(this.#props.queryNode, (0, select_parser_js_1.parseSelectExpressionOrList)(this.#parseContext, selection)),
+            queryNode: query_node_js_1.QueryNode.cloneWithReturning(this.#props.queryNode, (0, select_parser_js_1.parseSelectExpressionOrList)(this.#props.parseContext, selection)),
         });
     }
     /**
@@ -557,10 +620,10 @@ class QueryBuilder {
      * that support `returning` such as postgres.
      */
     returningAll() {
-        ensureCanHaveReturningClause(this.#props.queryNode);
+        assertCanHaveReturningClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: query_node_js_1.QueryNode.cloneWithReturning(this.#props.queryNode, (0, select_parser_js_1.parseSelectAllArgs)()),
+            queryNode: query_node_js_1.QueryNode.cloneWithReturning(this.#props.queryNode, (0, select_parser_js_1.parseSelectAll)()),
         });
     }
     /**
@@ -650,17 +713,17 @@ class QueryBuilder {
      * ```
      */
     orderBy(orderBy, direction = 'asc') {
-        ensureCanHaveOrderByClause(this.#props.queryNode);
+        assertCanHaveOrderByClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithOrderByItem(this.#props.queryNode, order_by_item_node_js_1.OrderByItemNode.create((0, reference_parser_js_1.parseReferenceExpression)(this.#parseContext, orderBy), direction)),
+            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithOrderByItem(this.#props.queryNode, order_by_item_node_js_1.OrderByItemNode.create((0, reference_parser_js_1.parseReferenceExpression)(this.#props.parseContext, orderBy), direction)),
         });
     }
     groupBy(orderBy) {
-        ensureCanHaveGroupByClause(this.#props.queryNode);
+        assertCanHaveGroupByClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithGroupByItems(this.#props.queryNode, (0, reference_parser_js_1.parseReferenceExpressionOrList)(this.#parseContext, orderBy).map(group_by_item_node_js_1.GroupByItemNode.create)),
+            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithGroupByItems(this.#props.queryNode, (0, reference_parser_js_1.parseReferenceExpressionOrList)(this.#props.parseContext, orderBy).map(group_by_item_node_js_1.GroupByItemNode.create)),
         });
     }
     /**
@@ -688,7 +751,7 @@ class QueryBuilder {
      * ```
      */
     limit(limit) {
-        ensureCanHaveLimit(this.#props.queryNode);
+        assertCanHaveLimit(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
             queryNode: select_query_node_js_1.SelectQueryNode.cloneWithLimit(this.#props.queryNode, limit_node_js_1.LimitNode.create(limit)),
@@ -709,7 +772,7 @@ class QueryBuilder {
      * ```
      */
     offset(offset) {
-        ensureCanHaveOffset(this.#props.queryNode);
+        assertCanHaveOffset(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
             queryNode: select_query_node_js_1.SelectQueryNode.cloneWithOffset(this.#props.queryNode, offset_node_js_1.OffsetNode.create(offset)),
@@ -759,7 +822,8 @@ class QueryBuilder {
         const compildQuery = this.#props.executor.compileQuery(node, this.#props.queryId);
         const result = await this.#props.executor.executeQuery(compildQuery, this.#props.queryId);
         if (insert_query_node_js_1.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) {
@@ -769,8 +833,9 @@ class QueryBuilder {
                 return [];
             }
         }
-        else if (update_query_node_js_1.UpdateQueryNode.is(node) || index_js_1.DeleteQueryNode.is(node)) {
-            if (this.#props.adapter.supportsReturning && node.returning) {
+        else if (update_query_node_js_1.UpdateQueryNode.is(node) || delete_query_node_js_1.DeleteQueryNode.is(node)) {
+            if (this.#props.parseContext.adapter.supportsReturning &&
+                node.returning) {
                 return result.rows;
             }
             else if (result.numUpdatedOrDeletedRows != null) {
@@ -807,9 +872,6 @@ class QueryBuilder {
         }
         return result;
     }
-    get #parseContext() {
-        return (0, parse_context_js_1.createParseContext)(this.#props.adapter);
-    }
 }
 exports.QueryBuilder = QueryBuilder;
 (0, prevent_await_js_1.preventAwait)(QueryBuilder, "don't await QueryBuilder instances directly. To execute the query you need to call `execute` or `executeTakeFirst`.");
@@ -854,62 +916,72 @@ class NoResultError extends Error {
     }
 }
 exports.NoResultError = NoResultError;
-function ensureCanHaveWhereClause(node) {
+function assertCanHaveWhereClause(node) {
     if (!query_node_js_1.QueryNode.isFilterable(node)) {
         throw new Error('only select, delete and update queries can have a where clause');
     }
 }
-function ensureCanHaveHavingClause(node) {
+function assertCanHaveHavingClause(node) {
     if (!select_query_node_js_1.SelectQueryNode.is(node)) {
         throw new Error('only select queries can have a having clause');
     }
 }
-function ensureCanHaveSelectClause(node) {
+function assertCanHaveSelectClause(node) {
     if (!select_query_node_js_1.SelectQueryNode.is(node)) {
         throw new Error('only a select query can have selections');
     }
 }
-function ensureCanHaveJoins(node) {
+function assertCanHaveJoins(node) {
     if (!query_node_js_1.QueryNode.isFilterable(node)) {
         throw new Error('only select, delete and update queries can have joins');
     }
 }
-function ensureCanHaveInsertValues(node) {
+function assertCanHaveInsertValues(node) {
     if (!insert_query_node_js_1.InsertQueryNode.is(node)) {
         throw new Error('only an insert query can have insert values');
     }
 }
-function ensureCanHaveOnConflict(node) {
+function assertCanHaveInsertIgnore(node) {
+    if (!insert_query_node_js_1.InsertQueryNode.is(node)) {
+        throw new Error('only an insert query can have the ignore clause');
+    }
+}
+function assertCanHaveOnConflict(node) {
     if (!insert_query_node_js_1.InsertQueryNode.is(node)) {
         throw new Error('only an insert query can have an on conflict clause');
     }
 }
-function ensureCanHaveUpdates(node) {
+function assertCanHaveOnDuplicateKey(node) {
+    if (!insert_query_node_js_1.InsertQueryNode.is(node)) {
+        throw new Error('only an insert query can have an on duplicate key clause');
+    }
+}
+function assertCanHaveUpdates(node) {
     if (!update_query_node_js_1.UpdateQueryNode.is(node)) {
         throw new Error('only an update query can set values');
     }
 }
-function ensureCanHaveReturningClause(node) {
+function assertCanHaveReturningClause(node) {
     if (!query_node_js_1.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 (!select_query_node_js_1.SelectQueryNode.is(node)) {
         throw new Error('only a select query can have an order by clause');
     }
 }
-function ensureCanHaveGroupByClause(node) {
+function assertCanHaveGroupByClause(node) {
     if (!select_query_node_js_1.SelectQueryNode.is(node)) {
         throw new Error('only a select query can have a group by clause');
     }
 }
-function ensureCanHaveLimit(node) {
+function assertCanHaveLimit(node) {
     if (!select_query_node_js_1.SelectQueryNode.is(node)) {
         throw new Error('only a select query can have a limit');
     }
 }
-function ensureCanHaveOffset(node) {
+function assertCanHaveOffset(node) {
     if (!select_query_node_js_1.SelectQueryNode.is(node)) {
         throw new Error('only a select query can have an offset');
     }

package/dist/cjs/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/cjs/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;