kysely 0.13.0 → 0.15.1

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

@@ -7,13 +7,14 @@ const insert_query_node_js_1 = require("../operation-node/insert-query-node.js")
 const query_node_js_1 = require("../operation-node/query-node.js");
 const update_set_parser_js_1 = require("../parser/update-set-parser.js");
 const prevent_await_js_1 = require("../util/prevent-await.js");
-const on_conflict_parser_js_1 = require("../parser/on-conflict-parser.js");
 const object_utils_js_1 = require("../util/object-utils.js");
 const on_duplicate_key_node_js_1 = require("../operation-node/on-duplicate-key-node.js");
 const insert_result_js_1 = require("./insert-result.js");
 const no_result_error_js_1 = require("./no-result-error.js");
 const complex_expression_parser_js_1 = require("../parser/complex-expression-parser.js");
 const column_node_js_1 = require("../operation-node/column-node.js");
+const on_conflict_builder_js_1 = require("./on-conflict-builder.js");
+const on_conflict_node_js_1 = require("../operation-node/on-conflict-node.js");
 class InsertQueryBuilder {
     #props;
     constructor(props) {
@@ -85,14 +86,6 @@ class InsertQueryBuilder {
             }),
         });
     }
-    onConflictDoNothing(target) {
-        return new InsertQueryBuilder({
-            ...this.#props,
-            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.
      *
@@ -103,7 +96,7 @@ class InsertQueryBuilder {
      * occurs.
      *
      * This is only supported on some dialects like MySQL. On most dialects you should
-     * use the {@link onConflictDoNothing} method.
+     * use the {@link onConflict} method.
      *
      * ### Examples
      *
@@ -122,11 +115,148 @@ class InsertQueryBuilder {
             }),
         });
     }
-    onConflictUpdate(target, updates) {
+    /**
+     * Adds an `on conflict` clause to the query.
+     *
+     * `on conflict` is only supported by some dialects like PostgreSQL and SQLite. On MySQL
+     * you can use {@link ignore} and {@link onDuplicateKeyUpdate} to achieve similar results.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * await db
+     *   .insertInto('pet')
+     *   .values({
+     *     name: 'Catto',
+     *     species: 'cat',
+     *   })
+     *   .onConflict((oc) => oc
+     *     .column('name')
+     *     .doUpdateSet({ species: 'hamster' })
+     *   )
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * insert into "pet" ("name", "species")
+     * values ($1, $2)
+     * on conflict ("name")
+     * do update set "species" = $3
+     * ```
+     *
+     * You can provide the name of the constraint instead of a column name:
+     *
+     * ```ts
+     * await db
+     *   .insertInto('pet')
+     *   .values({
+     *     name: 'Catto',
+     *     species: 'cat',
+     *   })
+     *   .onConflict((oc) => oc
+     *     .constraint('pet_name_key')
+     *     .doUpdateSet({ species: 'hamster' })
+     *   )
+     *   .execute()
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * insert into "pet" ("name", "species")
+     * values ($1, $2)
+     * on conflict on constraint "pet_name_key"
+     * do update set "species" = $3
+     * ```
+     *
+     * You can also specify an expression as the conflict target in case
+     * the unique index is an expression index:
+     *
+     * ```ts
+     * await db
+     *   .insertInto('pet')
+     *   .values({
+     *     name: 'Catto',
+     *     species: 'cat',
+     *   })
+     *   .onConflict((oc) => oc
+     *     .expression(db.raw('lower(name)'))
+     *     .doUpdateSet({ species: 'hamster' })
+     *   )
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * insert into "pet" ("name", "species")
+     * values ($1, $2)
+     * on conflict (lower(name))
+     * do update set "species" = $3
+     * ```
+     *
+     * You can add a filter for the update statement like this:
+     *
+     * ```ts
+     * await db
+     *   .insertInto('pet')
+     *   .values({
+     *     name: 'Catto',
+     *     species: 'cat',
+     *   })
+     *   .onConflict((oc) => oc
+     *     .column('name')
+     *     .doUpdateSet({ species: 'hamster' })
+     *     .where('excluded.name', '!=', 'Catto'')
+     *   )
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * insert into "pet" ("name", "species")
+     * values ($1, $2)
+     * on conflict ("name")
+     * do update set "species" = $3
+     * where "excluded"."name" != $4
+     * ```
+     *
+     * You can create an `on conflict do nothing` clauses like this:
+     *
+     * ```ts
+     * await db
+     *   .insertInto('pet')
+     *   .values({
+     *     name: 'Catto',
+     *     species: 'cat',
+     *   })
+     *   .onConflict((oc) => oc
+     *     .column('name')
+     *     .doNothing()
+     *   )
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * insert into "pet" ("name", "species")
+     * values ($1, $2)
+     * on conflict ("name") do nothing
+     * ```
+     */
+    onConflict(callback) {
         return new InsertQueryBuilder({
             ...this.#props,
             queryNode: insert_query_node_js_1.InsertQueryNode.cloneWith(this.#props.queryNode, {
-                onConflict: (0, on_conflict_parser_js_1.parseOnConflictUpdate)(this.#props.parseContext, target, updates),
+                onConflict: callback(new on_conflict_builder_js_1.OnConflictBuilder({
+                    onConflictNode: on_conflict_node_js_1.OnConflictNode.create(),
+                    parseContext: this.#props.parseContext,
+                })).toOperationNode(),
             }),
         });
     }
@@ -137,7 +267,7 @@ class InsertQueryBuilder {
      * 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.
+     * use {@link onConflict} instead.
      *
      * ### Examples
      *
@@ -180,9 +310,9 @@ class InsertQueryBuilder {
      *   .selectAll()
      *   .call((qb) => {
      *     if (something) {
-     *       return qb.onConflictDoNothing('something')
+     *       return qb.onConflict((oc) => oc.column('something').doNothing())
      *     } else {
-     *       return qb.onConflictDoNothing('something_else')
+     *       return qb.onConflict((oc) => oc.column('something_else').doNothing())
      *     }
      *   })
      *   .execute()